;;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: CL-USER; Base: 10 -*-
;;; Regex test case perl-584.retest from Perl.
;;;
;;; This file is automatically generated from Perl's test data with
;;; Perl 5.008004 at 2004-05-24 03:18:05 UTC.
;;;
;;; See: http://www.perl.com/ for Perl.
;;;
;

;;;; perl-584.retest/1: abc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/1"
  "abc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/2: abc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/2"
  "abc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/3: abc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/3"
  "abc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/4: abc
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/4"
  "abc"
  "xbc"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/5: abc
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/5"
  "abc"
  "axc"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/6: abc
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/6"
  "abc"
  "abx"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/7: abc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/7"
  "abc"
  "xabcy"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/8: abc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/8"
  "abc"
  "xabcy"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/9: abc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/9"
  "abc"
  "xabcy"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/10: abc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/10"
  "abc"
  "ababc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/11: abc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/11"
  "abc"
  "ababc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/12: abc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/12"
  "abc"
  "ababc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/13: ab*c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/13"
  "ab*c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/14: ab*c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/14"
  "ab*c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/15: ab*c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/15"
  "ab*c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/16: ab*bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/16"
  "ab*bc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/17: ab*bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/17"
  "ab*bc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/18: ab*bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/18"
  "ab*bc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/19: ab*bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/19"
  "ab*bc"
  "abbc"
  '(:single-line nil)
  (list "abbc") )

;;;; perl-584.retest/20: ab*bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/20"
  "ab*bc"
  "abbc"
  '(:single-line nil)
  (list "abbc") )

;;;; perl-584.retest/21: ab*bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/21"
  "ab*bc"
  "abbc"
  '(:single-line nil)
  (list "abbc") )

;;;; perl-584.retest/22: ab*bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/22"
  "ab*bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/23: ab*bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/23"
  "ab*bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/24: ab*bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/24"
  "ab*bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/25: .{1}
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/25"
  ".{1}"
  "abbbbc"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/26: .{1}
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/26"
  ".{1}"
  "abbbbc"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/27: .{1}
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/27"
  ".{1}"
  "abbbbc"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/28: .{3,4}
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/28"
  ".{3,4}"
  "abbbbc"
  '(:single-line nil)
  (list "abbb") )

;;;; perl-584.retest/29: .{3,4}
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/29"
  ".{3,4}"
  "abbbbc"
  '(:single-line nil)
  (list "abbb") )

;;;; perl-584.retest/30: .{3,4}
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/30"
  ".{3,4}"
  "abbbbc"
  '(:single-line nil)
  (list "abbb") )

;;;; perl-584.retest/31: ab{0,}bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/31"
  "ab{0,}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/32: ab{0,}bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/32"
  "ab{0,}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/33: ab{0,}bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/33"
  "ab{0,}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/34: ab+bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/34"
  "ab+bc"
  "abbc"
  '(:single-line nil)
  (list "abbc") )

;;;; perl-584.retest/35: ab+bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/35"
  "ab+bc"
  "abbc"
  '(:single-line nil)
  (list "abbc") )

;;;; perl-584.retest/36: ab+bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/36"
  "ab+bc"
  "abbc"
  '(:single-line nil)
  (list "abbc") )

;;;; perl-584.retest/37: ab+bc
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/37"
  "ab+bc"
  "abc"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/38: ab+bc
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/38"
  "ab+bc"
  "abq"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/39: ab{1,}bc
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/39"
  "ab{1,}bc"
  "abq"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/40: ab+bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/40"
  "ab+bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/41: ab+bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/41"
  "ab+bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/42: ab+bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/42"
  "ab+bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/43: ab{1,}bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/43"
  "ab{1,}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/44: ab{1,}bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/44"
  "ab{1,}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/45: ab{1,}bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/45"
  "ab{1,}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/46: ab{1,3}bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/46"
  "ab{1,3}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/47: ab{1,3}bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/47"
  "ab{1,3}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/48: ab{1,3}bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/48"
  "ab{1,3}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/49: ab{3,4}bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/49"
  "ab{3,4}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/50: ab{3,4}bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/50"
  "ab{3,4}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/51: ab{3,4}bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/51"
  "ab{3,4}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; perl-584.retest/52: ab{4,5}bc
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/52"
  "ab{4,5}bc"
  "abbbbc"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/53: ab?bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/53"
  "ab?bc"
  "abbc"
  '(:single-line nil)
  (list "abbc") )

;;;; perl-584.retest/54: ab?bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/54"
  "ab?bc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/55: ab{0,1}bc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/55"
  "ab{0,1}bc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/56: ab?bc
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/56"
  "ab?bc"
  "abbbbc"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/57: ab?c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/57"
  "ab?c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/58: ab{0,1}c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/58"
  "ab{0,1}c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/59: ^abc$
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/59"
  "^abc$"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/60: ^abc$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/60"
  "^abc$"
  "abcc"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/61: ^abc
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/61"
  "^abc"
  "abcc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/62: ^abc$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/62"
  "^abc$"
  "aabc"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/63: abc$
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/63"
  "abc$"
  "aabc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/64: abc$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/64"
  "abc$"
  "aabcd"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/65: ^
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/65"
  "^"
  "abc"
  '(:single-line nil)
  (list "") )

;;;; perl-584.retest/66: $
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/66"
  "$"
  "abc"
  '(:single-line nil)
  (list "") )

;;;; perl-584.retest/67: a.c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/67"
  "a.c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/68: a.c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/68"
  "a.c"
  "axc"
  '(:single-line nil)
  (list "axc") )

;;;; perl-584.retest/69: a.*c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/69"
  "a.*c"
  "axyzc"
  '(:single-line nil)
  (list "axyzc") )

;;;; perl-584.retest/70: a.*c
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/70"
  "a.*c"
  "axyzd"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/71: a[bc]d
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/71"
  "a[bc]d"
  "abc"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/72: a[bc]d
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/72"
  "a[bc]d"
  "abd"
  '(:single-line nil)
  (list "abd") )

;;;; perl-584.retest/73: a[b-d]e
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/73"
  "a[b-d]e"
  "abd"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/74: a[b-d]e
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/74"
  "a[b-d]e"
  "ace"
  '(:single-line nil)
  (list "ace") )

;;;; perl-584.retest/75: a[b-d]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/75"
  "a[b-d]"
  "aac"
  '(:single-line nil)
  (list "ac") )

;;;; perl-584.retest/76: a[-b]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/76"
  "a[-b]"
  "a-"
  '(:single-line nil)
  (list "a-") )

;;;; perl-584.retest/77: a[b-]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/77"
  "a[b-]"
  "a-"
  '(:single-line nil)
  (list "a-") )

;;;; perl-584.retest/78: a[b-a]
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/78"
  "a[b-a]"
  "-"
  '(:single-line nil)
  :compile   ; Invalid [] range "b-a"
 )

;;;; perl-584.retest/79: a[]b
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/79"
  "a[]b"
  "-"
  '(:single-line nil)
  :compile   ; Unmatched [
 )

;;;; perl-584.retest/80: a[
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/80"
  "a["
  "-"
  '(:single-line nil)
  :compile   ; Unmatched [
 )

;;;; perl-584.retest/81: a]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/81"
  "a]"
  "a]"
  '(:single-line nil)
  (list "a]") )

;;;; perl-584.retest/82: a[]]b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/82"
  "a[]]b"
  "a]b"
  '(:single-line nil)
  (list "a]b") )

;;;; perl-584.retest/83: a[^bc]d
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/83"
  "a[^bc]d"
  "aed"
  '(:single-line nil)
  (list "aed") )

;;;; perl-584.retest/84: a[^bc]d
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/84"
  "a[^bc]d"
  "abd"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/85: a[^-b]c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/85"
  "a[^-b]c"
  "adc"
  '(:single-line nil)
  (list "adc") )

;;;; perl-584.retest/86: a[^-b]c
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/86"
  "a[^-b]c"
  "a-c"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/87: a[^]b]c
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/87"
  "a[^]b]c"
  "a]c"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/88: a[^]b]c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/88"
  "a[^]b]c"
  "adc"
  '(:single-line nil)
  (list "adc") )

;;;; perl-584.retest/89: \ba\b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/89"
  "\\ba\\b"
  "a-"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/90: \ba\b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/90"
  "\\ba\\b"
  "-a"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/91: \ba\b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/91"
  "\\ba\\b"
  "-a-"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/92: \by\b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/92"
  "\\by\\b"
  "xy"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/93: \by\b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/93"
  "\\by\\b"
  "yz"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/94: \by\b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/94"
  "\\by\\b"
  "xyz"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/95: \Ba\B
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/95"
  "\\Ba\\B"
  "a-"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/96: \Ba\B
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/96"
  "\\Ba\\B"
  "-a"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/97: \Ba\B
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/97"
  "\\Ba\\B"
  "-a-"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/98: \By\b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/98"
  "\\By\\b"
  "xy"
  '(:single-line nil)
  (list "y") )

;;;; perl-584.retest/99: \By\b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/99"
  "\\By\\b"
  "xy"
  '(:single-line nil)
  (list "y") )

;;;; perl-584.retest/100: \By\b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/100"
  "\\By\\b"
  "xy"
  '(:single-line nil)
  (list "y") )

;;;; perl-584.retest/101: \By\b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/101"
  "\\By\\b"
  "xy"
  '(:single-line nil)
  (list "y") )

;;;; perl-584.retest/102: \by\B
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/102"
  "\\by\\B"
  "yz"
  '(:single-line nil)
  (list "y") )

;;;; perl-584.retest/103: \By\B
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/103"
  "\\By\\B"
  "xyz"
  '(:single-line nil)
  (list "y") )

;;;; perl-584.retest/104: \w
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/104"
  "\\w"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/105: \w
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/105"
  "\\w"
  "-"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/106: \W
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/106"
  "\\W"
  "a"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/107: \W
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/107"
  "\\W"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; perl-584.retest/108: a\sb
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/108"
  "a\\sb"
  "a b"
  '(:single-line nil)
  (list "a b") )

;;;; perl-584.retest/109: a\sb
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/109"
  "a\\sb"
  "a-b"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/110: a\Sb
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/110"
  "a\\Sb"
  "a b"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/111: a\Sb
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/111"
  "a\\Sb"
  "a-b"
  '(:single-line nil)
  (list "a-b") )

;;;; perl-584.retest/112: \d
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/112"
  "\\d"
  "1"
  '(:single-line nil)
  (list "1") )

;;;; perl-584.retest/113: \d
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/113"
  "\\d"
  "-"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/114: \D
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/114"
  "\\D"
  "1"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/115: \D
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/115"
  "\\D"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; perl-584.retest/116: [\w]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/116"
  "[\\w]"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/117: [\w]
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/117"
  "[\\w]"
  "-"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/118: [\W]
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/118"
  "[\\W]"
  "a"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/119: [\W]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/119"
  "[\\W]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; perl-584.retest/120: a[\s]b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/120"
  "a[\\s]b"
  "a b"
  '(:single-line nil)
  (list "a b") )

;;;; perl-584.retest/121: a[\s]b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/121"
  "a[\\s]b"
  "a-b"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/122: a[\S]b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/122"
  "a[\\S]b"
  "a b"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/123: a[\S]b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/123"
  "a[\\S]b"
  "a-b"
  '(:single-line nil)
  (list "a-b") )

;;;; perl-584.retest/124: [\d]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/124"
  "[\\d]"
  "1"
  '(:single-line nil)
  (list "1") )

;;;; perl-584.retest/125: [\d]
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/125"
  "[\\d]"
  "-"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/126: [\D]
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/126"
  "[\\D]"
  "1"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/127: [\D]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/127"
  "[\\D]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; perl-584.retest/128: ab|cd
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/128"
  "ab|cd"
  "abc"
  '(:single-line nil)
  (list "ab") )

;;;; perl-584.retest/129: ab|cd
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/129"
  "ab|cd"
  "abcd"
  '(:single-line nil)
  (list "ab") )

;;;; perl-584.retest/130: ()ef
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/130"
  "()ef"
  "def"
  '(:single-line nil)
  (list
    "ef"
    "" ) )

;;;; perl-584.retest/131: ()ef
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/131"
  "()ef"
  "def"
  '(:single-line nil)
  (list
    "ef"
    "" ) )

;;;; perl-584.retest/132: ()ef
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/132"
  "()ef"
  "def"
  '(:single-line nil)
  (list
    "ef"
    "" ) )

;;;; perl-584.retest/133: ()ef
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/133"
  "()ef"
  "def"
  '(:single-line nil)
  (list
    "ef"
    "" ) )

;;;; perl-584.retest/134: ()ef
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/134"
  "()ef"
  "def"
  '(:single-line nil)
  (list
    "ef"
    "" ) )

;;;; perl-584.retest/135: *a
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/135"
  "*a"
  "-"
  '(:single-line nil)
  :compile   ; Quantifier follows nothing
 )

;;;; perl-584.retest/136: (*)b
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/136"
  "(*)b"
  "-"
  '(:single-line nil)
  :compile   ; Quantifier follows nothing
 )

;;;; perl-584.retest/137: $b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/137"
  "$b"
  "b"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/138: a\
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/138"
  "a\\"
  "-"
  '(:single-line nil)
  :compile   ; Search pattern not terminated
 )

;;;; perl-584.retest/139: a\(b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/139"
  "a\\(b"
  "a(b"
  '(:single-line nil)
  (list "a(b") )

;;;; perl-584.retest/140: a\(*b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/140"
  "a\\(*b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; perl-584.retest/141: a\(*b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/141"
  "a\\(*b"
  "a((b"
  '(:single-line nil)
  (list "a((b") )

;;;; perl-584.retest/142: a\\b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/142"
  "a\\\\b"
  "a\\b"
  '(:single-line nil)
  (list "a\\b") )

;;;; perl-584.retest/143: abc)
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/143"
  "abc)"
  "-"
  '(:single-line nil)
  :compile   ; Unmatched )
 )

;;;; perl-584.retest/144: (abc
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/144"
  "(abc"
  "-"
  '(:single-line nil)
  :compile   ; Unmatched (
 )

;;;; perl-584.retest/145: ((a))
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/145"
  "((a))"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a" ) )

;;;; perl-584.retest/146: ((a))
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/146"
  "((a))"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a" ) )

;;;; perl-584.retest/147: ((a))
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/147"
  "((a))"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a" ) )

;;;; perl-584.retest/148: ((a))
;;;
;;;    Expect is NOT true due to bug of Perl. (b)
;
(test-case
  "perl-584/148"
  "((a))"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a" ) )

;;;; perl-584.retest/149: ((a))
;;;
;;;    Expect is NOT true due to bug of Perl. (b)
;
(test-case
  "perl-584/149"
  "((a))"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a" ) )

;;;; perl-584.retest/150: (a)b(c)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/150"
  "(a)b(c)"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "a"
    "c" ) )

;;;; perl-584.retest/151: (a)b(c)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/151"
  "(a)b(c)"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "a"
    "c" ) )

;;;; perl-584.retest/152: (a)b(c)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/152"
  "(a)b(c)"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "a"
    "c" ) )

;;;; perl-584.retest/153: a+b+c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/153"
  "a+b+c"
  "aabbabc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/154: a{1,}b{1,}c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/154"
  "a{1,}b{1,}c"
  "aabbabc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/155: a**
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/155"
  "a**"
  "-"
  '(:single-line nil)
  :compile   ; Nested quantifiers
 )

;;;; perl-584.retest/156: a.+?c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/156"
  "a.+?c"
  "abcabc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/157: (a+|b)*
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/157"
  "(a+|b)*"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; perl-584.retest/158: (a+|b)*
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/158"
  "(a+|b)*"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; perl-584.retest/159: (a+|b)*
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/159"
  "(a+|b)*"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; perl-584.retest/160: (a+|b)*
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/160"
  "(a+|b)*"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; perl-584.retest/161: (a+|b)*
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/161"
  "(a+|b)*"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; perl-584.retest/162: (a+|b){0,}
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/162"
  "(a+|b){0,}"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; perl-584.retest/163: (a+|b)+
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/163"
  "(a+|b)+"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; perl-584.retest/164: (a+|b){1,}
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/164"
  "(a+|b){1,}"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; perl-584.retest/165: (a+|b)?
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/165"
  "(a+|b)?"
  "ab"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; perl-584.retest/166: (a+|b){0,1}
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/166"
  "(a+|b){0,1}"
  "ab"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; perl-584.retest/167: )(
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/167"
  ")("
  "-"
  '(:single-line nil)
  :compile   ; Unmatched )
 )

;;;; perl-584.retest/168: [^ab]*
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/168"
  "[^ab]*"
  "cde"
  '(:single-line nil)
  (list "cde") )

;;;; perl-584.retest/169: abc
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/169"
  "abc"
  ""
  '(:single-line nil)
  nil )

;;;; perl-584.retest/170: a*
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/170"
  "a*"
  ""
  '(:single-line nil)
  (list "") )

;;;; perl-584.retest/171: ([abc])*d
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/171"
  "([abc])*d"
  "abbbcd"
  '(:single-line nil)
  (list
    "abbbcd"
    "c" ) )

;;;; perl-584.retest/172: ([abc])*bcd
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/172"
  "([abc])*bcd"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "a" ) )

;;;; perl-584.retest/173: a|b|c|d|e
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/173"
  "a|b|c|d|e"
  "e"
  '(:single-line nil)
  (list "e") )

;;;; perl-584.retest/174: (a|b|c|d|e)f
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/174"
  "(a|b|c|d|e)f"
  "ef"
  '(:single-line nil)
  (list
    "ef"
    "e" ) )

;;;; perl-584.retest/175: (a|b|c|d|e)f
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/175"
  "(a|b|c|d|e)f"
  "ef"
  '(:single-line nil)
  (list
    "ef"
    "e" ) )

;;;; perl-584.retest/176: (a|b|c|d|e)f
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/176"
  "(a|b|c|d|e)f"
  "ef"
  '(:single-line nil)
  (list
    "ef"
    "e" ) )

;;;; perl-584.retest/177: (a|b|c|d|e)f
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/177"
  "(a|b|c|d|e)f"
  "ef"
  '(:single-line nil)
  (list
    "ef"
    "e" ) )

;;;; perl-584.retest/178: (a|b|c|d|e)f
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/178"
  "(a|b|c|d|e)f"
  "ef"
  '(:single-line nil)
  (list
    "ef"
    "e" ) )

;;;; perl-584.retest/179: abcd*efg
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/179"
  "abcd*efg"
  "abcdefg"
  '(:single-line nil)
  (list "abcdefg") )

;;;; perl-584.retest/180: ab*
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/180"
  "ab*"
  "xabyabbbz"
  '(:single-line nil)
  (list "ab") )

;;;; perl-584.retest/181: ab*
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/181"
  "ab*"
  "xayabbbz"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/182: (ab|cd)e
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/182"
  "(ab|cd)e"
  "abcde"
  '(:single-line nil)
  (list
    "cde"
    "cd" ) )

;;;; perl-584.retest/183: [abhgefdc]ij
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/183"
  "[abhgefdc]ij"
  "hij"
  '(:single-line nil)
  (list "hij") )

;;;; perl-584.retest/184: ^(ab|cd)e
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/184"
  "^(ab|cd)e"
  "abcde"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/185: (abc|)ef
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/185"
  "(abc|)ef"
  "abcdef"
  '(:single-line nil)
  (list
    "ef"
    "" ) )

;;;; perl-584.retest/186: (a|b)c*d
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/186"
  "(a|b)c*d"
  "abcd"
  '(:single-line nil)
  (list
    "bcd"
    "b" ) )

;;;; perl-584.retest/187: (ab|ab*)bc
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/187"
  "(ab|ab*)bc"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "a" ) )

;;;; perl-584.retest/188: a([bc]*)c*
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/188"
  "a([bc]*)c*"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "bc" ) )

;;;; perl-584.retest/189: a([bc]*)(c*d)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/189"
  "a([bc]*)(c*d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "bc"
    "d" ) )

;;;; perl-584.retest/190: a([bc]*)(c*d)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/190"
  "a([bc]*)(c*d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "bc"
    "d" ) )

;;;; perl-584.retest/191: a([bc]*)(c*d)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/191"
  "a([bc]*)(c*d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "bc"
    "d" ) )

;;;; perl-584.retest/192: a([bc]*)(c*d)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/192"
  "a([bc]*)(c*d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "bc"
    "d" ) )

;;;; perl-584.retest/193: a([bc]*)(c*d)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/193"
  "a([bc]*)(c*d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "bc"
    "d" ) )

;;;; perl-584.retest/194: a([bc]*)(c*d)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/194"
  "a([bc]*)(c*d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "bc"
    "d" ) )

;;;; perl-584.retest/195: a([bc]*)(c*d)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/195"
  "a([bc]*)(c*d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "bc"
    "d" ) )

;;;; perl-584.retest/196: a([bc]+)(c*d)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/196"
  "a([bc]+)(c*d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "bc"
    "d" ) )

;;;; perl-584.retest/197: a([bc]*)(c+d)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/197"
  "a([bc]*)(c+d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "b"
    "cd" ) )

;;;; perl-584.retest/198: a([bc]*)(c+d)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/198"
  "a([bc]*)(c+d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "b"
    "cd" ) )

;;;; perl-584.retest/199: a([bc]*)(c+d)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/199"
  "a([bc]*)(c+d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "b"
    "cd" ) )

;;;; perl-584.retest/200: a([bc]*)(c+d)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/200"
  "a([bc]*)(c+d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "b"
    "cd" ) )

;;;; perl-584.retest/201: a([bc]*)(c+d)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/201"
  "a([bc]*)(c+d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "b"
    "cd" ) )

;;;; perl-584.retest/202: a([bc]*)(c+d)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/202"
  "a([bc]*)(c+d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "b"
    "cd" ) )

;;;; perl-584.retest/203: a([bc]*)(c+d)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/203"
  "a([bc]*)(c+d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "b"
    "cd" ) )

;;;; perl-584.retest/204: a[bcd]*dcdcde
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/204"
  "a[bcd]*dcdcde"
  "adcdcde"
  '(:single-line nil)
  (list "adcdcde") )

;;;; perl-584.retest/205: a[bcd]+dcdcde
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/205"
  "a[bcd]+dcdcde"
  "adcdcde"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/206: (ab|a)b*c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/206"
  "(ab|a)b*c"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/207: (ab|a)b*c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/207"
  "(ab|a)b*c"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/208: (ab|a)b*c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/208"
  "(ab|a)b*c"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/209: (ab|a)b*c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/209"
  "(ab|a)b*c"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/210: (ab|a)b*c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/210"
  "(ab|a)b*c"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/211: ((a)(b)c)(d)
;;;
;;;    Matched with 4 captures. (y)
;
(test-case
  "perl-584/211"
  "((a)(b)c)(d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "abc"
    "a"
    "b"
    "d" ) )

;;;; perl-584.retest/212: ((a)(b)c)(d)
;;;
;;;    Matched with 4 captures. (y)
;
(test-case
  "perl-584/212"
  "((a)(b)c)(d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "abc"
    "a"
    "b"
    "d" ) )

;;;; perl-584.retest/213: ((a)(b)c)(d)
;;;
;;;    Matched with 4 captures. (y)
;
(test-case
  "perl-584/213"
  "((a)(b)c)(d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "abc"
    "a"
    "b"
    "d" ) )

;;;; perl-584.retest/214: ((a)(b)c)(d)
;;;
;;;    Matched with 4 captures. (y)
;
(test-case
  "perl-584/214"
  "((a)(b)c)(d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "abc"
    "a"
    "b"
    "d" ) )

;;;; perl-584.retest/215: ((a)(b)c)(d)
;;;
;;;    Matched with 4 captures. (y)
;
(test-case
  "perl-584/215"
  "((a)(b)c)(d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "abc"
    "a"
    "b"
    "d" ) )

;;;; perl-584.retest/216: ((a)(b)c)(d)
;;;
;;;    Matched with 4 captures. (y)
;
(test-case
  "perl-584/216"
  "((a)(b)c)(d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "abc"
    "a"
    "b"
    "d" ) )

;;;; perl-584.retest/217: ((a)(b)c)(d)
;;;
;;;    Matched with 4 captures. (y)
;
(test-case
  "perl-584/217"
  "((a)(b)c)(d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "abc"
    "a"
    "b"
    "d" ) )

;;;; perl-584.retest/218: ((a)(b)c)(d)
;;;
;;;    Matched with 4 captures. (y)
;
(test-case
  "perl-584/218"
  "((a)(b)c)(d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "abc"
    "a"
    "b"
    "d" ) )

;;;; perl-584.retest/219: ((a)(b)c)(d)
;;;
;;;    Matched with 4 captures. (y)
;
(test-case
  "perl-584/219"
  "((a)(b)c)(d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "abc"
    "a"
    "b"
    "d" ) )

;;;; perl-584.retest/220: ((a)(b)c)(d)
;;;
;;;    Matched with 4 captures. (y)
;
(test-case
  "perl-584/220"
  "((a)(b)c)(d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "abc"
    "a"
    "b"
    "d" ) )

;;;; perl-584.retest/221: ((a)(b)c)(d)
;;;
;;;    Matched with 4 captures. (y)
;
(test-case
  "perl-584/221"
  "((a)(b)c)(d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "abc"
    "a"
    "b"
    "d" ) )

;;;; perl-584.retest/222: [a-zA-Z_][a-zA-Z0-9_]*
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/222"
  "[a-zA-Z_][a-zA-Z0-9_]*"
  "alpha"
  '(:single-line nil)
  (list "alpha") )

;;;; perl-584.retest/223: ^a(bc+|b[eh])g|.h$
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/223"
  "^a(bc+|b[eh])g|.h$"
  "abh"
  '(:single-line nil)
  (list "bh") )

;;;; perl-584.retest/224: (bc+d$|ef*g.|h?i(j|k))
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/224"
  "(bc+d$|ef*g.|h?i(j|k))"
  "effgz"
  '(:single-line nil)
  (list
    "effgz"
    "effgz" ) )

;;;; perl-584.retest/225: (bc+d$|ef*g.|h?i(j|k))
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/225"
  "(bc+d$|ef*g.|h?i(j|k))"
  "ij"
  '(:single-line nil)
  (list
    "ij"
    "ij"
    "j" ) )

;;;; perl-584.retest/226: (bc+d$|ef*g.|h?i(j|k))
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/226"
  "(bc+d$|ef*g.|h?i(j|k))"
  "effg"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/227: (bc+d$|ef*g.|h?i(j|k))
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/227"
  "(bc+d$|ef*g.|h?i(j|k))"
  "bcdd"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/228: (bc+d$|ef*g.|h?i(j|k))
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/228"
  "(bc+d$|ef*g.|h?i(j|k))"
  "reffgz"
  '(:single-line nil)
  (list
    "effgz"
    "effgz" ) )

;;;; perl-584.retest/229: ((((((((((a))))))))))
;;;
;;;    Matched with 10 captures. (y)
;
(test-case
  "perl-584/229"
  "((((((((((a))))))))))"
  "a"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a" ) )

;;;; perl-584.retest/230: ((((((((((a))))))))))
;;;
;;;    Matched with 10 captures. (y)
;
(test-case
  "perl-584/230"
  "((((((((((a))))))))))"
  "a"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a" ) )

;;;; perl-584.retest/231: ((((((((((a))))))))))
;;;
;;;    Matched with 10 captures. (y)
;
(test-case
  "perl-584/231"
  "((((((((((a))))))))))"
  "a"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a" ) )

;;;; perl-584.retest/232: ((((((((((a))))))))))
;;;
;;;    Matched with 10 captures. (y)
;
(test-case
  "perl-584/232"
  "((((((((((a))))))))))"
  "a"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a" ) )

;;;; perl-584.retest/233: ((((((((((a))))))))))
;;;
;;;    Matched with 10 captures. (y)
;
(test-case
  "perl-584/233"
  "((((((((((a))))))))))"
  "a"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a" ) )

;;;; perl-584.retest/234: ((((((((((a))))))))))\10
;;;
;;;    Matched with 10 captures. (y)
;
(test-case
  "perl-584/234"
  "((((((((((a))))))))))\\10"
  "aa"
  '(:single-line nil)
  (list
    "aa"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a" ) )

;;;; perl-584.retest/235: ((((((((((a))))))))))${bang}
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/235"
  "((((((((((a))))))))))\\041"
  "aa"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/236: ((((((((((a))))))))))${bang}
;;;
;;;    Matched with 10 captures. (y)
;
(test-case
  "perl-584/236"
  "((((((((((a))))))))))\\041"
  "a!"
  '(:single-line nil)
  (list
    "a!"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a" ) )

;;;; perl-584.retest/237: (((((((((a)))))))))
;;;
;;;    Matched with 9 captures. (y)
;
(test-case
  "perl-584/237"
  "(((((((((a)))))))))"
  "a"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a" ) )

;;;; perl-584.retest/238: multiple words of text
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/238"
  "multiple words of text"
  "uh-uh"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/239: multiple words
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/239"
  "multiple words"
  "multiple words, yeah"
  '(:single-line nil)
  (list "multiple words") )

;;;; perl-584.retest/240: (.*)c(.*)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/240"
  "(.*)c(.*)"
  "abcde"
  '(:single-line nil)
  (list
    "abcde"
    "ab"
    "de" ) )

;;;; perl-584.retest/241: \((.*), (.*)\)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/241"
  "\\((.*), (.*)\\)"
  "(a, b)"
  '(:single-line nil)
  (list
    "(a, b)"
    "a"
    "b" ) )

;;;; perl-584.retest/242: [k]
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/242"
  "[k]"
  "ab"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/243: abcd
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/243"
  "abcd"
  "abcd"
  '(:single-line nil)
  (list "abcd") )

;;;; perl-584.retest/244: a(bc)d
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/244"
  "a(bc)d"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "bc" ) )

;;;; perl-584.retest/245: a[-]?c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/245"
  "a[-]?c"
  "ac"
  '(:single-line nil)
  (list "ac") )

;;;; perl-584.retest/246: (abc)\1
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/246"
  "(abc)\\1"
  "abcabc"
  '(:single-line nil)
  (list
    "abcabc"
    "abc" ) )

;;;; perl-584.retest/247: ([a-c]*)\1
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/247"
  "([a-c]*)\\1"
  "abcabc"
  '(:single-line nil)
  (list
    "abcabc"
    "abc" ) )

;;;; perl-584.retest/248: \1
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/248"
  "\\1"
  "-"
  '(:single-line nil)
  :compile   ; Reference to nonexistent group
 )

;;;; perl-584.retest/249: \2
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/249"
  "\\2"
  "-"
  '(:single-line nil)
  :compile   ; Reference to nonexistent group
 )

;;;; perl-584.retest/250: (a)|\1
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/250"
  "(a)|\\1"
  "a"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; perl-584.retest/251: (a)|\1
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/251"
  "(a)|\\1"
  "x"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/252: (a)|\2
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/252"
  "(a)|\\2"
  "-"
  '(:single-line nil)
  :compile   ; Reference to nonexistent group
 )

;;;; perl-584.retest/253: (([a-c])b*?\2)*
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/253"
  "(([a-c])b*?\\2)*"
  "ababbbcbc"
  '(:single-line nil)
  (list
    "ababb"
    "bb"
    "b" ) )

;;;; perl-584.retest/254: (([a-c])b*?\2){3}
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/254"
  "(([a-c])b*?\\2){3}"
  "ababbbcbc"
  '(:single-line nil)
  (list
    "ababbbcbc"
    "cbc"
    "c" ) )

;;;; perl-584.retest/255: ((\3|b)\2(a)x)+
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/255"
  "((\\3|b)\\2(a)x)+"
  "aaxabxbaxbbx"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/256: ((\3|b)\2(a)x)+
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-584/256"
  "((\\3|b)\\2(a)x)+"
  "aaaxabaxbaaxbbax"
  '(:single-line nil)
  (list
    "bbax"
    "bbax"
    "b"
    "a" ) )

;;;; perl-584.retest/257: ((\3|b)\2(a)){2,}
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-584/257"
  "((\\3|b)\\2(a)){2,}"
  "bbaababbabaaaaabbaaaabba"
  '(:single-line nil)
  (list
    "bbaaaabba"
    "bba"
    "b"
    "a" ) )

;;;; perl-584.retest/258: (a)|(b)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/258"
  "(a)|(b)"
  "b"
  '(:single-line nil)
  (list
    "b"
    nil
    "b" ) )

;;;; perl-584.retest/259: (a)|(b)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/259"
  "(a)|(b)"
  "b"
  '(:single-line nil)
  (list
    "b"
    nil
    "b" ) )

;;;; perl-584.retest/260: (a)|(b)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/260"
  "(a)|(b)"
  "b"
  '(:single-line nil)
  (list
    "b"
    nil
    "b" ) )

;;;; perl-584.retest/261: (a)|(b)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/261"
  "(a)|(b)"
  "b"
  '(:single-line nil)
  (list
    "b"
    nil
    "b" ) )

;;;; perl-584.retest/262: (a)|(b)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/262"
  "(a)|(b)"
  "b"
  '(:single-line nil)
  (list
    "b"
    nil
    "b" ) )

;;;; perl-584.retest/263: (a)|(b)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/263"
  "(a)|(b)"
  "b"
  '(:single-line nil)
  (list
    "b"
    nil
    "b" ) )

;;;; perl-584.retest/264: 'abc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/264"
  "abc"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/265: 'abc'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/265"
  "abc"
  "XBC"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/266: 'abc'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/266"
  "abc"
  "AXC"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/267: 'abc'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/267"
  "abc"
  "ABX"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/268: 'abc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/268"
  "abc"
  "XABCY"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/269: 'abc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/269"
  "abc"
  "ABABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/270: 'ab*c'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/270"
  "ab*c"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/271: 'ab*bc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/271"
  "ab*bc"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/272: 'ab*bc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/272"
  "ab*bc"
  "ABBC"
  '(:ignore-case t :single-line nil)
  (list "ABBC") )

;;;; perl-584.retest/273: 'ab*?bc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/273"
  "ab*?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; perl-584.retest/274: 'ab{0,}?bc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/274"
  "ab{0,}?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; perl-584.retest/275: 'ab+?bc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/275"
  "ab+?bc"
  "ABBC"
  '(:ignore-case t :single-line nil)
  (list "ABBC") )

;;;; perl-584.retest/276: 'ab+bc'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/276"
  "ab+bc"
  "ABC"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/277: 'ab+bc'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/277"
  "ab+bc"
  "ABQ"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/278: 'ab{1,}bc'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/278"
  "ab{1,}bc"
  "ABQ"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/279: 'ab+bc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/279"
  "ab+bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; perl-584.retest/280: 'ab{1,}?bc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/280"
  "ab{1,}?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; perl-584.retest/281: 'ab{1,3}?bc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/281"
  "ab{1,3}?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; perl-584.retest/282: 'ab{3,4}?bc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/282"
  "ab{3,4}?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; perl-584.retest/283: 'ab{4,5}?bc'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/283"
  "ab{4,5}?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/284: 'ab??bc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/284"
  "ab??bc"
  "ABBC"
  '(:ignore-case t :single-line nil)
  (list "ABBC") )

;;;; perl-584.retest/285: 'ab??bc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/285"
  "ab??bc"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/286: 'ab{0,1}?bc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/286"
  "ab{0,1}?bc"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/287: 'ab??bc'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/287"
  "ab??bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/288: 'ab??c'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/288"
  "ab??c"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/289: 'ab{0,1}?c'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/289"
  "ab{0,1}?c"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/290: '^abc$'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/290"
  "^abc$"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/291: '^abc$'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/291"
  "^abc$"
  "ABCC"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/292: '^abc'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/292"
  "^abc"
  "ABCC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/293: '^abc$'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/293"
  "^abc$"
  "AABC"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/294: 'abc$'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/294"
  "abc$"
  "AABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/295: '^'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/295"
  "^"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "") )

;;;; perl-584.retest/296: '$'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/296"
  "$"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "") )

;;;; perl-584.retest/297: 'a.c'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/297"
  "a.c"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/298: 'a.c'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/298"
  "a.c"
  "AXC"
  '(:ignore-case t :single-line nil)
  (list "AXC") )

;;;; perl-584.retest/299: 'a.*?c'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/299"
  "a.*?c"
  "AXYZC"
  '(:ignore-case t :single-line nil)
  (list "AXYZC") )

;;;; perl-584.retest/300: 'a.*c'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/300"
  "a.*c"
  "AXYZD"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/301: 'a[bc]d'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/301"
  "a[bc]d"
  "ABC"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/302: 'a[bc]d'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/302"
  "a[bc]d"
  "ABD"
  '(:ignore-case t :single-line nil)
  (list "ABD") )

;;;; perl-584.retest/303: 'a[b-d]e'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/303"
  "a[b-d]e"
  "ABD"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/304: 'a[b-d]e'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/304"
  "a[b-d]e"
  "ACE"
  '(:ignore-case t :single-line nil)
  (list "ACE") )

;;;; perl-584.retest/305: 'a[b-d]'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/305"
  "a[b-d]"
  "AAC"
  '(:ignore-case t :single-line nil)
  (list "AC") )

;;;; perl-584.retest/306: 'a[-b]'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/306"
  "a[-b]"
  "A-"
  '(:ignore-case t :single-line nil)
  (list "A-") )

;;;; perl-584.retest/307: 'a[b-]'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/307"
  "a[b-]"
  "A-"
  '(:ignore-case t :single-line nil)
  (list "A-") )

;;;; perl-584.retest/308: 'a[b-a]'i
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/308"
  "a[b-a]"
  "-"
  '(:ignore-case t :single-line nil)
  :compile   ; Invalid [] range "b-a"
 )

;;;; perl-584.retest/309: 'a[]b'i
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/309"
  "a[]b"
  "-"
  '(:ignore-case t :single-line nil)
  :compile   ; Unmatched [
 )

;;;; perl-584.retest/310: 'a['i
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/310"
  "a["
  "-"
  '(:ignore-case t :single-line nil)
  :compile   ; Unmatched [
 )

;;;; perl-584.retest/311: 'a]'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/311"
  "a]"
  "A]"
  '(:ignore-case t :single-line nil)
  (list "A]") )

;;;; perl-584.retest/312: 'a[]]b'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/312"
  "a[]]b"
  "A]B"
  '(:ignore-case t :single-line nil)
  (list "A]B") )

;;;; perl-584.retest/313: 'a[^bc]d'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/313"
  "a[^bc]d"
  "AED"
  '(:ignore-case t :single-line nil)
  (list "AED") )

;;;; perl-584.retest/314: 'a[^bc]d'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/314"
  "a[^bc]d"
  "ABD"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/315: 'a[^-b]c'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/315"
  "a[^-b]c"
  "ADC"
  '(:ignore-case t :single-line nil)
  (list "ADC") )

;;;; perl-584.retest/316: 'a[^-b]c'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/316"
  "a[^-b]c"
  "A-C"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/317: 'a[^]b]c'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/317"
  "a[^]b]c"
  "A]C"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/318: 'a[^]b]c'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/318"
  "a[^]b]c"
  "ADC"
  '(:ignore-case t :single-line nil)
  (list "ADC") )

;;;; perl-584.retest/319: 'ab|cd'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/319"
  "ab|cd"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "AB") )

;;;; perl-584.retest/320: 'ab|cd'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/320"
  "ab|cd"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list "AB") )

;;;; perl-584.retest/321: '()ef'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/321"
  "()ef"
  "DEF"
  '(:ignore-case t :single-line nil)
  (list
    "EF"
    "" ) )

;;;; perl-584.retest/322: '*a'i
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/322"
  "*a"
  "-"
  '(:ignore-case t :single-line nil)
  :compile   ; Quantifier follows nothing
 )

;;;; perl-584.retest/323: '(*)b'i
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/323"
  "(*)b"
  "-"
  '(:ignore-case t :single-line nil)
  :compile   ; Quantifier follows nothing
 )

;;;; perl-584.retest/324: '$b'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/324"
  "$b"
  "B"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/325: 'a\'i
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/325"
  "a\\"
  "-"
  '(:ignore-case t :single-line nil)
  :compile   ; Search pattern not terminated
 )

;;;; perl-584.retest/326: 'a\(b'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/326"
  "a\\(b"
  "A(B"
  '(:ignore-case t :single-line nil)
  (list "A(B") )

;;;; perl-584.retest/327: 'a\(*b'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/327"
  "a\\(*b"
  "AB"
  '(:ignore-case t :single-line nil)
  (list "AB") )

;;;; perl-584.retest/328: 'a\(*b'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/328"
  "a\\(*b"
  "A((B"
  '(:ignore-case t :single-line nil)
  (list "A((B") )

;;;; perl-584.retest/329: 'a\\b'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/329"
  "a\\\\b"
  "A\\B"
  '(:ignore-case t :single-line nil)
  (list "A\\B") )

;;;; perl-584.retest/330: 'abc)'i
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/330"
  "abc)"
  "-"
  '(:ignore-case t :single-line nil)
  :compile   ; Unmatched )
 )

;;;; perl-584.retest/331: '(abc'i
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/331"
  "(abc"
  "-"
  '(:ignore-case t :single-line nil)
  :compile   ; Unmatched (
 )

;;;; perl-584.retest/332: '((a))'i
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/332"
  "((a))"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A"
    "A" ) )

;;;; perl-584.retest/333: '(a)b(c)'i
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/333"
  "(a)b(c)"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABC"
    "A"
    "C" ) )

;;;; perl-584.retest/334: 'a+b+c'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/334"
  "a+b+c"
  "AABBABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/335: 'a{1,}b{1,}c'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/335"
  "a{1,}b{1,}c"
  "AABBABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/336: 'a**'i
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/336"
  "a**"
  "-"
  '(:ignore-case t :single-line nil)
  :compile   ; Nested quantifiers
 )

;;;; perl-584.retest/337: 'a.+?c'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/337"
  "a.+?c"
  "ABCABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/338: 'a.*?c'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/338"
  "a.*?c"
  "ABCABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/339: 'a.{0,5}?c'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/339"
  "a.{0,5}?c"
  "ABCABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; perl-584.retest/340: '(a+|b)*'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/340"
  "(a+|b)*"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "AB"
    "B" ) )

;;;; perl-584.retest/341: '(a+|b){0,}'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/341"
  "(a+|b){0,}"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "AB"
    "B" ) )

;;;; perl-584.retest/342: '(a+|b)+'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/342"
  "(a+|b)+"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "AB"
    "B" ) )

;;;; perl-584.retest/343: '(a+|b){1,}'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/343"
  "(a+|b){1,}"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "AB"
    "B" ) )

;;;; perl-584.retest/344: '(a+|b)?'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/344"
  "(a+|b)?"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A" ) )

;;;; perl-584.retest/345: '(a+|b){0,1}'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/345"
  "(a+|b){0,1}"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A" ) )

;;;; perl-584.retest/346: '(a+|b){0,1}?'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/346"
  "(a+|b){0,1}?"
  "AB"
  '(:ignore-case t :single-line nil)
  (list "") )

;;;; perl-584.retest/347: ')('i
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/347"
  ")("
  "-"
  '(:ignore-case t :single-line nil)
  :compile   ; Unmatched )
 )

;;;; perl-584.retest/348: '[^ab]*'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/348"
  "[^ab]*"
  "CDE"
  '(:ignore-case t :single-line nil)
  (list "CDE") )

;;;; perl-584.retest/349: 'abc'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/349"
  "abc"
  ""
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/350: 'a*'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/350"
  "a*"
  ""
  '(:ignore-case t :single-line nil)
  (list "") )

;;;; perl-584.retest/351: '([abc])*d'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/351"
  "([abc])*d"
  "ABBBCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABBBCD"
    "C" ) )

;;;; perl-584.retest/352: '([abc])*bcd'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/352"
  "([abc])*bcd"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "A" ) )

;;;; perl-584.retest/353: 'a|b|c|d|e'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/353"
  "a|b|c|d|e"
  "E"
  '(:ignore-case t :single-line nil)
  (list "E") )

;;;; perl-584.retest/354: '(a|b|c|d|e)f'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/354"
  "(a|b|c|d|e)f"
  "EF"
  '(:ignore-case t :single-line nil)
  (list
    "EF"
    "E" ) )

;;;; perl-584.retest/355: 'abcd*efg'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/355"
  "abcd*efg"
  "ABCDEFG"
  '(:ignore-case t :single-line nil)
  (list "ABCDEFG") )

;;;; perl-584.retest/356: 'ab*'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/356"
  "ab*"
  "XABYABBBZ"
  '(:ignore-case t :single-line nil)
  (list "AB") )

;;;; perl-584.retest/357: 'ab*'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/357"
  "ab*"
  "XAYABBBZ"
  '(:ignore-case t :single-line nil)
  (list "A") )

;;;; perl-584.retest/358: '(ab|cd)e'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/358"
  "(ab|cd)e"
  "ABCDE"
  '(:ignore-case t :single-line nil)
  (list
    "CDE"
    "CD" ) )

;;;; perl-584.retest/359: '[abhgefdc]ij'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/359"
  "[abhgefdc]ij"
  "HIJ"
  '(:ignore-case t :single-line nil)
  (list "HIJ") )

;;;; perl-584.retest/360: '^(ab|cd)e'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/360"
  "^(ab|cd)e"
  "ABCDE"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/361: '(abc|)ef'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/361"
  "(abc|)ef"
  "ABCDEF"
  '(:ignore-case t :single-line nil)
  (list
    "EF"
    "" ) )

;;;; perl-584.retest/362: '(a|b)c*d'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/362"
  "(a|b)c*d"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "BCD"
    "B" ) )

;;;; perl-584.retest/363: '(ab|ab*)bc'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/363"
  "(ab|ab*)bc"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABC"
    "A" ) )

;;;; perl-584.retest/364: 'a([bc]*)c*'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/364"
  "a([bc]*)c*"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABC"
    "BC" ) )

;;;; perl-584.retest/365: 'a([bc]*)(c*d)'i
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/365"
  "a([bc]*)(c*d)"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "BC"
    "D" ) )

;;;; perl-584.retest/366: 'a([bc]+)(c*d)'i
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/366"
  "a([bc]+)(c*d)"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "BC"
    "D" ) )

;;;; perl-584.retest/367: 'a([bc]*)(c+d)'i
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/367"
  "a([bc]*)(c+d)"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "B"
    "CD" ) )

;;;; perl-584.retest/368: 'a[bcd]*dcdcde'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/368"
  "a[bcd]*dcdcde"
  "ADCDCDE"
  '(:ignore-case t :single-line nil)
  (list "ADCDCDE") )

;;;; perl-584.retest/369: 'a[bcd]+dcdcde'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/369"
  "a[bcd]+dcdcde"
  "ADCDCDE"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/370: '(ab|a)b*c'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/370"
  "(ab|a)b*c"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABC"
    "AB" ) )

;;;; perl-584.retest/371: '((a)(b)c)(d)'i
;;;
;;;    Matched with 4 captures. (y)
;
(test-case
  "perl-584/371"
  "((a)(b)c)(d)"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "ABC"
    "A"
    "B"
    "D" ) )

;;;; perl-584.retest/372: '[a-zA-Z_][a-zA-Z0-9_]*'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/372"
  "[a-zA-Z_][a-zA-Z0-9_]*"
  "ALPHA"
  '(:ignore-case t :single-line nil)
  (list "ALPHA") )

;;;; perl-584.retest/373: '^a(bc+|b[eh])g|.h$'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/373"
  "^a(bc+|b[eh])g|.h$"
  "ABH"
  '(:ignore-case t :single-line nil)
  (list "BH") )

;;;; perl-584.retest/374: '(bc+d$|ef*g.|h?i(j|k))'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/374"
  "(bc+d$|ef*g.|h?i(j|k))"
  "EFFGZ"
  '(:ignore-case t :single-line nil)
  (list
    "EFFGZ"
    "EFFGZ" ) )

;;;; perl-584.retest/375: '(bc+d$|ef*g.|h?i(j|k))'i
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/375"
  "(bc+d$|ef*g.|h?i(j|k))"
  "IJ"
  '(:ignore-case t :single-line nil)
  (list
    "IJ"
    "IJ"
    "J" ) )

;;;; perl-584.retest/376: '(bc+d$|ef*g.|h?i(j|k))'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/376"
  "(bc+d$|ef*g.|h?i(j|k))"
  "EFFG"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/377: '(bc+d$|ef*g.|h?i(j|k))'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/377"
  "(bc+d$|ef*g.|h?i(j|k))"
  "BCDD"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/378: '(bc+d$|ef*g.|h?i(j|k))'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/378"
  "(bc+d$|ef*g.|h?i(j|k))"
  "REFFGZ"
  '(:ignore-case t :single-line nil)
  (list
    "EFFGZ"
    "EFFGZ" ) )

;;;; perl-584.retest/379: '((((((((((a))))))))))'i
;;;
;;;    Matched with 10 captures. (y)
;
(test-case
  "perl-584/379"
  "((((((((((a))))))))))"
  "A"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A" ) )

;;;; perl-584.retest/380: '((((((((((a))))))))))\10'i
;;;
;;;    Matched with 10 captures. (y)
;
(test-case
  "perl-584/380"
  "((((((((((a))))))))))\\10"
  "AA"
  '(:ignore-case t :single-line nil)
  (list
    "AA"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A" ) )

;;;; perl-584.retest/381: '((((((((((a))))))))))${bang}'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/381"
  "((((((((((a))))))))))\\041"
  "AA"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/382: '((((((((((a))))))))))${bang}'i
;;;
;;;    Matched with 10 captures. (y)
;
(test-case
  "perl-584/382"
  "((((((((((a))))))))))\\041"
  "A!"
  '(:ignore-case t :single-line nil)
  (list
    "A!"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A" ) )

;;;; perl-584.retest/383: '(((((((((a)))))))))'i
;;;
;;;    Matched with 9 captures. (y)
;
(test-case
  "perl-584/383"
  "(((((((((a)))))))))"
  "A"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A" ) )

;;;; perl-584.retest/384: '(?:(?:(?:(?:(?:(?:(?:(?:(?:(a))))))))))'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/384"
  "(?:(?:(?:(?:(?:(?:(?:(?:(?:(a))))))))))"
  "A"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A" ) )

;;;; perl-584.retest/385: '(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/385"
  "(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))"
  "C"
  '(:ignore-case t :single-line nil)
  (list
    "C"
    "C" ) )

;;;; perl-584.retest/386: 'multiple words of text'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/386"
  "multiple words of text"
  "UH-UH"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/387: 'multiple words'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/387"
  "multiple words"
  "MULTIPLE WORDS, YEAH"
  '(:ignore-case t :single-line nil)
  (list "MULTIPLE WORDS") )

;;;; perl-584.retest/388: '(.*)c(.*)'i
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/388"
  "(.*)c(.*)"
  "ABCDE"
  '(:ignore-case t :single-line nil)
  (list
    "ABCDE"
    "AB"
    "DE" ) )

;;;; perl-584.retest/389: '\((.*), (.*)\)'i
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/389"
  "\\((.*), (.*)\\)"
  "(A, B)"
  '(:ignore-case t :single-line nil)
  (list
    "(A, B)"
    "A"
    "B" ) )

;;;; perl-584.retest/390: '[k]'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/390"
  "[k]"
  "AB"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/391: 'abcd'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/391"
  "abcd"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list "ABCD") )

;;;; perl-584.retest/392: 'a(bc)d'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/392"
  "a(bc)d"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "BC" ) )

;;;; perl-584.retest/393: 'a[-]?c'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/393"
  "a[-]?c"
  "AC"
  '(:ignore-case t :single-line nil)
  (list "AC") )

;;;; perl-584.retest/394: '(abc)\1'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/394"
  "(abc)\\1"
  "ABCABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABCABC"
    "ABC" ) )

;;;; perl-584.retest/395: '([a-c]*)\1'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/395"
  "([a-c]*)\\1"
  "ABCABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABCABC"
    "ABC" ) )

;;;; perl-584.retest/396: a(?!b).
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/396"
  "a(?!b)."
  "abad"
  '(:single-line nil)
  (list "ad") )

;;;; perl-584.retest/397: a(?=d).
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/397"
  "a(?=d)."
  "abad"
  '(:single-line nil)
  (list "ad") )

;;;; perl-584.retest/398: a(?=c|d).
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/398"
  "a(?=c|d)."
  "abad"
  '(:single-line nil)
  (list "ad") )

;;;; perl-584.retest/399: a(?:b|c|d)(.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/399"
  "a(?:b|c|d)(.)"
  "ace"
  '(:single-line nil)
  (list
    "ace"
    "e" ) )

;;;; perl-584.retest/400: a(?:b|c|d)*(.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/400"
  "a(?:b|c|d)*(.)"
  "ace"
  '(:single-line nil)
  (list
    "ace"
    "e" ) )

;;;; perl-584.retest/401: a(?:b|c|d)+?(.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/401"
  "a(?:b|c|d)+?(.)"
  "ace"
  '(:single-line nil)
  (list
    "ace"
    "e" ) )

;;;; perl-584.retest/402: a(?:b|c|d)+?(.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/402"
  "a(?:b|c|d)+?(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acd"
    "d" ) )

;;;; perl-584.retest/403: a(?:b|c|d)+(.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/403"
  "a(?:b|c|d)+(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdbe"
    "e" ) )

;;;; perl-584.retest/404: a(?:b|c|d){2}(.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/404"
  "a(?:b|c|d){2}(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdb"
    "b" ) )

;;;; perl-584.retest/405: a(?:b|c|d){4,5}(.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/405"
  "a(?:b|c|d){4,5}(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdb"
    "b" ) )

;;;; perl-584.retest/406: a(?:b|c|d){4,5}?(.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/406"
  "a(?:b|c|d){4,5}?(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcd"
    "d" ) )

;;;; perl-584.retest/407: ((foo)|(bar))*
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-584/407"
  "((foo)|(bar))*"
  "foobar"
  '(:single-line nil)
  (list
    "foobar"
    "bar"
    "foo"
    "bar" ) )

;;;; perl-584.retest/408: :(?:
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/408"
  "(?"
  "-"
  '(:single-line nil)
  :compile   ; Sequence (? incomplete
 )

;;;; perl-584.retest/409: a(?:b|c|d){6,7}(.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/409"
  "a(?:b|c|d){6,7}(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdbe"
    "e" ) )

;;;; perl-584.retest/410: a(?:b|c|d){6,7}?(.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/410"
  "a(?:b|c|d){6,7}?(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdbe"
    "e" ) )

;;;; perl-584.retest/411: a(?:b|c|d){5,6}(.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/411"
  "a(?:b|c|d){5,6}(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdbe"
    "e" ) )

;;;; perl-584.retest/412: a(?:b|c|d){5,6}?(.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/412"
  "a(?:b|c|d){5,6}?(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdb"
    "b" ) )

;;;; perl-584.retest/413: a(?:b|c|d){5,7}(.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/413"
  "a(?:b|c|d){5,7}(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdbe"
    "e" ) )

;;;; perl-584.retest/414: a(?:b|c|d){5,7}?(.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/414"
  "a(?:b|c|d){5,7}?(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdb"
    "b" ) )

;;;; perl-584.retest/415: a(?:b|(c|e){1,2}?|d)+?(.)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/415"
  "a(?:b|(c|e){1,2}?|d)+?(.)"
  "ace"
  '(:single-line nil)
  (list
    "ace"
    "c"
    "e" ) )

;;;; perl-584.retest/416: ^(.+)?B
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/416"
  "^(.+)?B"
  "AB"
  '(:single-line nil)
  (list
    "AB"
    "A" ) )

;;;; perl-584.retest/417: ^([^a-z])|(\^)$
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/417"
  "^([^a-z])|(\\^)$"
  "."
  '(:single-line nil)
  (list
    "."
    "." ) )

;;;; perl-584.retest/418: ^[<>]&
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/418"
  "^[<>]&"
  "<&OUT"
  '(:single-line nil)
  (list "<&") )

;;;; perl-584.retest/419: ^(a\1?){4}$
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/419"
  "^(a\\1?){4}$"
  "aaaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaaaa"
    "aaaa" ) )

;;;; perl-584.retest/420: ^(a\1?){4}$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/420"
  "^(a\\1?){4}$"
  "aaaaaaaaa"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/421: ^(a\1?){4}$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/421"
  "^(a\\1?){4}$"
  "aaaaaaaaaaa"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/422: ^(a(?(1)\1)){4}$
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/422"
  "^(a(?(1)\\1)){4}$"
  "aaaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaaaa"
    "aaaa" ) )

;;;; perl-584.retest/423: ^(a(?(1)\1)){4}$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/423"
  "^(a(?(1)\\1)){4}$"
  "aaaaaaaaa"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/424: ^(a(?(1)\1)){4}$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/424"
  "^(a(?(1)\\1)){4}$"
  "aaaaaaaaaaa"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/425: ((a{4})+)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/425"
  "((a{4})+)"
  "aaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaa"
    "aaaaaaaa"
    "aaaa" ) )

;;;; perl-584.retest/426: (((aa){2})+)
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-584/426"
  "(((aa){2})+)"
  "aaaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaa"
    "aaaaaaaa"
    "aaaa"
    "aa" ) )

;;;; perl-584.retest/427: (((a{2}){2})+)
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-584/427"
  "(((a{2}){2})+)"
  "aaaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaa"
    "aaaaaaaa"
    "aaaa"
    "aa" ) )

;;;; perl-584.retest/428: (?:(f)(o)(o)|(b)(a)(r))*
;;;
;;;    Matched with 6 captures. (y)
;
(test-case
  "perl-584/428"
  "(?:(f)(o)(o)|(b)(a)(r))*"
  "foobar"
  '(:single-line nil)
  (list
    "foobar"
    "f"
    "o"
    "o"
    "b"
    "a"
    "r" ) )

;;;; perl-584.retest/429: (?<=a)b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/429"
  "(?<=a)b"
  "ab"
  '(:single-line nil)
  (list "b") )

;;;; perl-584.retest/430: (?<=a)b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/430"
  "(?<=a)b"
  "cb"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/431: (?<=a)b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/431"
  "(?<=a)b"
  "b"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/432: (?<!c)b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/432"
  "(?<!c)b"
  "ab"
  '(:single-line nil)
  (list "b") )

;;;; perl-584.retest/433: (?<!c)b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/433"
  "(?<!c)b"
  "cb"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/434: (?<!c)b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/434"
  "(?<!c)b"
  "b"
  '(:single-line nil)
  (list "b") )

;;;; perl-584.retest/435: (?<!c)b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/435"
  "(?<!c)b"
  "b"
  '(:single-line nil)
  (list "b") )

;;;; perl-584.retest/436: (?<%)b
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/436"
  "(?<%)b"
  "-"
  '(:single-line nil)
  :compile   ; Sequence (?<%...) not recognized
 )

;;;; perl-584.retest/437: (?:..)*a
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/437"
  "(?:..)*a"
  "aba"
  '(:single-line nil)
  (list "aba") )

;;;; perl-584.retest/438: (?:..)*?a
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/438"
  "(?:..)*?a"
  "aba"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/439: ^(?:b|a(?=(.)))*\1
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/439"
  "^(?:b|a(?=(.)))*\\1"
  "abc"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; perl-584.retest/440: ^(){3,5}
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/440"
  "^(){3,5}"
  "abc"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; perl-584.retest/441: ^(a+)*ax
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/441"
  "^(a+)*ax"
  "aax"
  '(:single-line nil)
  (list
    "aax"
    "a" ) )

;;;; perl-584.retest/442: ^((a|b)+)*ax
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/442"
  "^((a|b)+)*ax"
  "aax"
  '(:single-line nil)
  (list
    "aax"
    "a"
    "a" ) )

;;;; perl-584.retest/443: ^((a|bc)+)*ax
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/443"
  "^((a|bc)+)*ax"
  "aax"
  '(:single-line nil)
  (list
    "aax"
    "a"
    "a" ) )

;;;; perl-584.retest/444: (a|x)*ab
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/444"
  "(a|x)*ab"
  "cab"
  '(:single-line nil)
  (list
    "ab"
    nil ) )

;;;; perl-584.retest/445: (a)*ab
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/445"
  "(a)*ab"
  "cab"
  '(:single-line nil)
  (list
    "ab"
    nil ) )

;;;; perl-584.retest/446: (?:(?i)a)b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/446"
  "(?:(?i)a)b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; perl-584.retest/447: ((?i)a)b
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/447"
  "((?i)a)b"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "a" ) )

;;;; perl-584.retest/448: (?:(?i)a)b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/448"
  "(?:(?i)a)b"
  "Ab"
  '(:single-line nil)
  (list "Ab") )

;;;; perl-584.retest/449: ((?i)a)b
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/449"
  "((?i)a)b"
  "Ab"
  '(:single-line nil)
  (list
    "Ab"
    "A" ) )

;;;; perl-584.retest/450: (?:(?i)a)b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/450"
  "(?:(?i)a)b"
  "aB"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/451: ((?i)a)b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/451"
  "((?i)a)b"
  "aB"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/452: (?i:a)b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/452"
  "(?i:a)b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; perl-584.retest/453: ((?i:a))b
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/453"
  "((?i:a))b"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "a" ) )

;;;; perl-584.retest/454: (?i:a)b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/454"
  "(?i:a)b"
  "Ab"
  '(:single-line nil)
  (list "Ab") )

;;;; perl-584.retest/455: ((?i:a))b
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/455"
  "((?i:a))b"
  "Ab"
  '(:single-line nil)
  (list
    "Ab"
    "A" ) )

;;;; perl-584.retest/456: (?i:a)b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/456"
  "(?i:a)b"
  "aB"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/457: ((?i:a))b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/457"
  "((?i:a))b"
  "aB"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/458: '(?:(?-i)a)b'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/458"
  "(?:(?-i)a)b"
  "ab"
  '(:ignore-case t :single-line nil)
  (list "ab") )

;;;; perl-584.retest/459: '((?-i)a)b'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/459"
  "((?-i)a)b"
  "ab"
  '(:ignore-case t :single-line nil)
  (list
    "ab"
    "a" ) )

;;;; perl-584.retest/460: '(?:(?-i)a)b'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/460"
  "(?:(?-i)a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list "aB") )

;;;; perl-584.retest/461: '((?-i)a)b'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/461"
  "((?-i)a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list
    "aB"
    "a" ) )

;;;; perl-584.retest/462: '(?:(?-i)a)b'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/462"
  "(?:(?-i)a)b"
  "Ab"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/463: '((?-i)a)b'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/463"
  "((?-i)a)b"
  "Ab"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/464: '(?:(?-i)a)b'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/464"
  "(?:(?-i)a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list "aB") )

;;;; perl-584.retest/465: '((?-i)a)b'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/465"
  "((?-i)a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list
    "aB"
    "a" ) )

;;;; perl-584.retest/466: '(?:(?-i)a)b'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/466"
  "(?:(?-i)a)b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/467: '((?-i)a)b'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/467"
  "((?-i)a)b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/468: '(?-i:a)b'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/468"
  "(?-i:a)b"
  "ab"
  '(:ignore-case t :single-line nil)
  (list "ab") )

;;;; perl-584.retest/469: '((?-i:a))b'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/469"
  "((?-i:a))b"
  "ab"
  '(:ignore-case t :single-line nil)
  (list
    "ab"
    "a" ) )

;;;; perl-584.retest/470: '(?-i:a)b'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/470"
  "(?-i:a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list "aB") )

;;;; perl-584.retest/471: '((?-i:a))b'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/471"
  "((?-i:a))b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list
    "aB"
    "a" ) )

;;;; perl-584.retest/472: '(?-i:a)b'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/472"
  "(?-i:a)b"
  "Ab"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/473: '((?-i:a))b'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/473"
  "((?-i:a))b"
  "Ab"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/474: '(?-i:a)b'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/474"
  "(?-i:a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list "aB") )

;;;; perl-584.retest/475: '((?-i:a))b'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/475"
  "((?-i:a))b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list
    "aB"
    "a" ) )

;;;; perl-584.retest/476: '(?-i:a)b'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/476"
  "(?-i:a)b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/477: '((?-i:a))b'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/477"
  "((?-i:a))b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/478: '((?-i:a.))b'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/478"
  "((?-i:a.))b"
  (backslash "a\\nB")
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/479: '((?s-i:a.))b'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/479"
  "((?s-i:a.))b"
  (backslash "a\\nB")
  '(:ignore-case t :single-line nil)
  (list
    (backslash "a\\nB")
    "a
" ) )

;;;; perl-584.retest/480: '((?s-i:a.))b'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/480"
  "((?s-i:a.))b"
  (backslash "B\\nB")
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/481: (?:c|d)(?:)(?:a(?:)(?:b)(?:b(?:))(?:b(?:)(?:b)))
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/481"
  "(?:c|d)(?:)(?:a(?:)(?:b)(?:b(?:))(?:b(?:)(?:b)))"
  "cabbbb"
  '(:single-line nil)
  (list "cabbbb") )

;;;; perl-584.retest/482: (?:c|d)(?:)(?:aaaaaaaa(?:)(?:bbbbbbbb)(?:bbbbbbbb(?:))(?:bbbbbbbb(?:)(?:bbbbbbbb)))
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/482"
  "(?:c|d)(?:)(?:aaaaaaaa(?:)(?:bbbbbbbb)(?:bbbbbbbb(?:))(?:bbbbbbbb(?:)(?:bbbbbbbb)))"
  "caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
  '(:single-line nil)
  (list "caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb") )

;;;; perl-584.retest/483: '(ab)\d\1'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/483"
  "(ab)\\d\\1"
  "Ab4ab"
  '(:ignore-case t :single-line nil)
  (list
    "Ab4ab"
    "Ab" ) )

;;;; perl-584.retest/484: '(ab)\d\1'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/484"
  "(ab)\\d\\1"
  "ab4Ab"
  '(:ignore-case t :single-line nil)
  (list
    "ab4Ab"
    "ab" ) )

;;;; perl-584.retest/485: foo\w*\d{4}baz
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/485"
  "foo\\w*\\d{4}baz"
  "foobar1234baz"
  '(:single-line nil)
  (list "foobar1234baz") )

;;;; perl-584.retest/486: a(?{})b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/486"
  "a(?{})b"
  "cabd"
  '(:single-line nil)
  (list "ab") )

;;;; perl-584.retest/487: a(?{)b
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/487"
  "a(?{)b"
  "-"
  '(:single-line nil)
  :compile   ; Sequence (?{...}) not terminated or not {}-balanced
 )

;;;; perl-584.retest/488: a(?{{})b
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/488"
  "a(?{{})b"
  "-"
  '(:single-line nil)
  :compile   ; Sequence (?{...}) not terminated or not {}-balanced
 )

;;;; perl-584.retest/489: a(?{}})b
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/489"
  "a(?{}})b"
  "-"
  '(:single-line nil)
  :compile   ; Sequence (?{...}) not terminated or not {}-balanced
 )

;;;; perl-584.retest/490: a(?{"{"})b
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/490"
  "a(?{\"{\"})b"
  "-"
  '(:single-line nil)
  :compile   ; Sequence (?{...}) not terminated or not {}-balanced
 )

;;;; perl-584.retest/491: a(?{"\{"})b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/491"
  "a(?{\"\\{\"})b"
  "cabd"
  '(:single-line nil)
  (list "ab") )

;;;; perl-584.retest/492: a(?{"{"}})b
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/492"
  "a(?{\"{\"}})b"
  "-"
  '(:single-line nil)
  :compile   ; Unmatched right curly bracket, at end of line syntax error, near ""{"}" Compilation failed in regexp
 )

;;;; perl-584.retest/493: a(?{$bl="\{"}).b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/493"
  "a(?{$bl=\"\\{\"}).b"
  "caxbd"
  '(:single-line nil)
  (list "axb") )

;;;; perl-584.retest/494: x(~~)*(?:(?:F)?)?
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/494"
  "x(~~)*(?:(?:F)?)?"
  "x~~"
  '(:single-line nil)
  (list
    "x~~"
    "~~" ) )

;;;; perl-584.retest/495: ^a(?#xxx){3}c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/495"
  "^a(?#xxx){3}c"
  "aaac"
  '(:single-line nil)
  (list "aaac") )

;;;; perl-584.retest/496: '^a (?#xxx) (?#yyy) {3}c'x
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/496"
  "^a (?#xxx) (?#yyy) {3}c"
  "aaac"
  '(:extended-syntax t :single-line nil)
  (list "aaac") )

;;;; perl-584.retest/497: (?<![cd])b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/497"
  "(?<![cd])b"
  "dbcb"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/498: (?<![cd])[ab]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/498"
  "(?<![cd])[ab]"
  "dbaacb"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/499: (?<!(c|d))b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/499"
  "(?<!(c|d))b"
  "dbcb"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/500: (?<!(c|d))[ab]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/500"
  "(?<!(c|d))[ab]"
  "dbaacb"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/501: (?<!cd)[ab]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/501"
  "(?<!cd)[ab]"
  "cdaccb"
  '(:single-line nil)
  (list "b") )

;;;; perl-584.retest/502: ^(?:a?b?)*$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/502"
  "^(?:a?b?)*$"
  "a--"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/503: ((?s)^a(.))((?m)^b$)
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-584/503"
  "((?s)^a(.))((?m)^b$)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    (backslash "a\\nb")
    "a
"
    "
"
    "b" ) )

;;;; perl-584.retest/504: ((?m)^b$)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/504"
  "((?m)^b$)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    "b"
    "b" ) )

;;;; perl-584.retest/505: (?m)^b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/505"
  "(?m)^b"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list "b") )

;;;; perl-584.retest/506: (?m)^(b)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/506"
  "(?m)^(b)"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list
    "b"
    "b" ) )

;;;; perl-584.retest/507: ((?m)^b)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/507"
  "((?m)^b)"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list
    "b"
    "b" ) )

;;;; perl-584.retest/508: \n((?m)^b)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/508"
  (backslash "\\n((?m)^b)")
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list
    (backslash "\\nb")
    "b" ) )

;;;; perl-584.retest/509: ((?s).)c(?!.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/509"
  "((?s).)c(?!.)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    (backslash "\\nc")
    "
" ) )

;;;; perl-584.retest/510: ((?s).)c(?!.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/510"
  "((?s).)c(?!.)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    (backslash "\\nc")
    "
" ) )

;;;; perl-584.retest/511: ((?s)b.)c(?!.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/511"
  "((?s)b.)c(?!.)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    (backslash "b\\nc")
    "b
" ) )

;;;; perl-584.retest/512: ((?s)b.)c(?!.)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/512"
  "((?s)b.)c(?!.)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    (backslash "b\\nc")
    "b
" ) )

;;;; perl-584.retest/513: ^b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/513"
  "^b"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/514: ()^b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/514"
  "()^b"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/515: ((?m)^b)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/515"
  "((?m)^b)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    "b"
    "b" ) )

;;;; perl-584.retest/516: (?(1)a|b)
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/516"
  "(?(1)a|b)"
  "a"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/517: (?(1)b|a)
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/517"
  "(?(1)b|a)"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/518: (x)?(?(1)a|b)
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/518"
  "(x)?(?(1)a|b)"
  "a"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/519: (x)?(?(1)b|a)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/519"
  "(x)?(?(1)b|a)"
  "a"
  '(:single-line nil)
  (list
    "a"
    nil ) )

;;;; perl-584.retest/520: ()?(?(1)b|a)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/520"
  "()?(?(1)b|a)"
  "a"
  '(:single-line nil)
  (list
    "a"
    nil ) )

;;;; perl-584.retest/521: ()(?(1)b|a)
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/521"
  "()(?(1)b|a)"
  "a"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/522: ()?(?(1)a|b)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/522"
  "()?(?(1)a|b)"
  "a"
  '(:single-line nil)
  (list
    "a"
    "" ) )

;;;; perl-584.retest/523: ^(\()?blah(?(1)(\)))$
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/523"
  "^(\\()?blah(?(1)(\\)))$"
  "(blah)"
  '(:single-line nil)
  (list
    "(blah)"
    "("
    ")" ) )

;;;; perl-584.retest/524: ^(\()?blah(?(1)(\)))$
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/524"
  "^(\\()?blah(?(1)(\\)))$"
  "blah"
  '(:single-line nil)
  (list
    "blah"
    nil ) )

;;;; perl-584.retest/525: ^(\()?blah(?(1)(\)))$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/525"
  "^(\\()?blah(?(1)(\\)))$"
  "blah)"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/526: ^(\()?blah(?(1)(\)))$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/526"
  "^(\\()?blah(?(1)(\\)))$"
  "(blah"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/527: ^(\(+)?blah(?(1)(\)))$
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/527"
  "^(\\(+)?blah(?(1)(\\)))$"
  "(blah)"
  '(:single-line nil)
  (list
    "(blah)"
    "("
    ")" ) )

;;;; perl-584.retest/528: ^(\(+)?blah(?(1)(\)))$
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/528"
  "^(\\(+)?blah(?(1)(\\)))$"
  "blah"
  '(:single-line nil)
  (list "blah") )

;;;; perl-584.retest/529: ^(\(+)?blah(?(1)(\)))$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/529"
  "^(\\(+)?blah(?(1)(\\)))$"
  "blah)"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/530: ^(\(+)?blah(?(1)(\)))$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/530"
  "^(\\(+)?blah(?(1)(\\)))$"
  "(blah"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/531: (?(1?)a|b)
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/531"
  "(?(1?)a|b)"
  "a"
  '(:single-line nil)
  :compile   ; Switch condition not recognized
 )

;;;; perl-584.retest/532: (?(1)a|b|c)
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/532"
  "(?(1)a|b|c)"
  "a"
  '(:single-line nil)
  :compile   ; Switch (?(condition)... contains too many branches
 )

;;;; perl-584.retest/533: (?(?{0})a|b)
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/533"
  "(?(?{0})a|b)"
  "a"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/534: (?(?{0})b|a)
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/534"
  "(?(?{0})b|a)"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/535: (?(?{1})b|a)
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/535"
  "(?(?{1})b|a)"
  "a"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/536: (?(?{1})a|b)
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/536"
  "(?(?{1})a|b)"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/537: (?(?!a)a|b)
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/537"
  "(?(?!a)a|b)"
  "a"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/538: (?(?!a)b|a)
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/538"
  "(?(?!a)b|a)"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/539: (?(?=a)b|a)
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/539"
  "(?(?=a)b|a)"
  "a"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/540: (?(?=a)a|b)
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/540"
  "(?(?=a)a|b)"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/541: (?=(a+?))(\1ab)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/541"
  "(?=(a+?))(\\1ab)"
  "aaab"
  '(:single-line nil)
  (list
    "aab"
    "a"
    "aab" ) )

;;;; perl-584.retest/542: ^(?=(a+?))\1ab
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/542"
  "^(?=(a+?))\\1ab"
  "aaab"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/543: (\w+:)+
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/543"
  "(\\w+:)+"
  "one:"
  '(:single-line nil)
  (list
    "one:"
    "one:" ) )

;;;; perl-584.retest/544: $(?<=^(a))
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/544"
  "$(?<=^(a))"
  "a"
  '(:single-line nil)
  (list
    ""
    "a" ) )

;;;; perl-584.retest/545: (?=(a+?))(\1ab)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/545"
  "(?=(a+?))(\\1ab)"
  "aaab"
  '(:single-line nil)
  (list
    "aab"
    "a"
    "aab" ) )

;;;; perl-584.retest/546: ^(?=(a+?))\1ab
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/546"
  "^(?=(a+?))\\1ab"
  "aaab"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/547: ([\w:]+::)?(\w+)$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/547"
  "([\\w:]+::)?(\\w+)$"
  "abcd:"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/548: ([\w:]+::)?(\w+)$
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/548"
  "([\\w:]+::)?(\\w+)$"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    nil
    "abcd" ) )

;;;; perl-584.retest/549: ([\w:]+::)?(\w+)$
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/549"
  "([\\w:]+::)?(\\w+)$"
  "xy:z:::abcd"
  '(:single-line nil)
  (list
    "xy:z:::abcd"
    "xy:z:::"
    "abcd" ) )

;;;; perl-584.retest/550: ^[^bcd]*(c+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/550"
  "^[^bcd]*(c+)"
  "aexycd"
  '(:single-line nil)
  (list
    "aexyc"
    "c" ) )

;;;; perl-584.retest/551: (a*)b+
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/551"
  "(a*)b+"
  "caab"
  '(:single-line nil)
  (list
    "aab"
    "aa" ) )

;;;; perl-584.retest/552: ([\w:]+::)?(\w+)$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/552"
  "([\\w:]+::)?(\\w+)$"
  "abcd:"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/553: ([\w:]+::)?(\w+)$
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/553"
  "([\\w:]+::)?(\\w+)$"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    nil
    "abcd" ) )

;;;; perl-584.retest/554: ([\w:]+::)?(\w+)$
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/554"
  "([\\w:]+::)?(\\w+)$"
  "xy:z:::abcd"
  '(:single-line nil)
  (list
    "xy:z:::abcd"
    "xy:z:::"
    "abcd" ) )

;;;; perl-584.retest/555: ^[^bcd]*(c+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/555"
  "^[^bcd]*(c+)"
  "aexycd"
  '(:single-line nil)
  (list
    "aexyc"
    "c" ) )

;;;; perl-584.retest/556: (?{$a=2})a*aa(?{local$a=$a+1})k*c(?{$b=$a})
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/556"
  "(?{$a=2})a*aa(?{local$a=$a+1})k*c(?{$b=$a})"
  "yaaxxaaaacd"
  '(:single-line nil)
  (list "aaaac") )

;;;; perl-584.retest/557: (?{$a=2})(a(?{local$a=$a+1}))*aak*c(?{$b=$a})
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/557"
  "(?{$a=2})(a(?{local$a=$a+1}))*aak*c(?{$b=$a})"
  "yaaxxaaaacd"
  '(:single-line nil)
  (list
    "aaaac"
    "a" ) )

;;;; perl-584.retest/558: (>a+)ab
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/558"
  "(>a+)ab"
  "aaab"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/559: (?>a+)b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/559"
  "(?>a+)b"
  "aaab"
  '(:single-line nil)
  (list "aaab") )

;;;; perl-584.retest/560: ([[:]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/560"
  "([[:]+)"
  "a:[b]:"
  '(:single-line nil)
  (list
    ":["
    ":[" ) )

;;;; perl-584.retest/561: ([[=]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/561"
  "([[=]+)"
  "a=[b]="
  '(:single-line nil)
  (list
    "=["
    "=[" ) )

;;;; perl-584.retest/562: ([[.]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/562"
  "([[.]+)"
  "a.[b]."
  '(:single-line nil)
  (list
    ".["
    ".[" ) )

;;;; perl-584.retest/563: [a[:xyz:
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/563"
  "[a[:xyz:"
  "-"
  '(:single-line nil)
  :compile   ; Unmatched [
 )

;;;; perl-584.retest/564: [a[:xyz:]
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/564"
  "[a[:xyz:]"
  "-"
  '(:single-line nil)
  :compile   ; POSIX class [:xyz:] unknown
 )

;;;; perl-584.retest/565: [a[:]b[:c]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/565"
  "[a[:]b[:c]"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/566: ([a[:xyz:]b]+)
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/566"
  "([a[:xyz:]b]+)"
  "pbaq"
  '(:single-line nil)
  :compile   ; POSIX class [:xyz:] unknown
 )

;;;; perl-584.retest/567: [a[:]b[:c]
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/567"
  "[a[:]b[:c]"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; perl-584.retest/568: ([[:alpha:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/568"
  "([[:alpha:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "ABcd"
    "ABcd" ) )

;;;; perl-584.retest/569: ([[:alnum:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/569"
  "([[:alnum:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "ABcd01Xy"
    "ABcd01Xy" ) )

;;;; perl-584.retest/570: ([[:ascii:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/570"
  "([[:ascii:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    (backslash "ABcd01Xy__--  \\u0000\\u0000")
    (backslash "ABcd01Xy__--  \\u0000\\u0000") ) )

;;;; perl-584.retest/571: ([[:cntrl:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/571"
  "([[:cntrl:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    (backslash "\\u0000\\u0000")
    (backslash "\\u0000\\u0000") ) )

;;;; perl-584.retest/572: ([[:digit:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/572"
  "([[:digit:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "01"
    "01" ) )

;;;; perl-584.retest/573: ([[:graph:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/573"
  "([[:graph:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "ABcd01Xy__--"
    "ABcd01Xy__--" ) )

;;;; perl-584.retest/574: ([[:lower:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/574"
  "([[:lower:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "cd"
    "cd" ) )

;;;; perl-584.retest/575: ([[:print:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/575"
  "([[:print:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "ABcd01Xy__--  "
    "ABcd01Xy__--  " ) )

;;;; perl-584.retest/576: ([[:punct:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/576"
  "([[:punct:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "__--"
    "__--" ) )

;;;; perl-584.retest/577: ([[:space:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/577"
  "([[:space:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "  "
    "  " ) )

;;;; perl-584.retest/578: ([[:word:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/578"
  "([[:word:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "ABcd01Xy__"
    "ABcd01Xy__" ) )

;;;; perl-584.retest/579: ([[:upper:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/579"
  "([[:upper:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "AB"
    "AB" ) )

;;;; perl-584.retest/580: ([[:xdigit:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/580"
  "([[:xdigit:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "ABcd01"
    "ABcd01" ) )

;;;; perl-584.retest/581: ([[:^alpha:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/581"
  "([[:^alpha:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "01"
    "01" ) )

;;;; perl-584.retest/582: ([[:^alnum:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/582"
  "([[:^alnum:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    (backslash "__--  \\u0000\\u0000\\u00FF\\u00FF")
    (backslash "__--  \\u0000\\u0000\\u00FF\\u00FF") ) )

;;;; perl-584.retest/583: ([[:^ascii:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/583"
  "([[:^ascii:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    (backslash "\\u00FF\\u00FF")
    (backslash "\\u00FF\\u00FF") ) )

;;;; perl-584.retest/584: ([[:^cntrl:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/584"
  "([[:^cntrl:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "ABcd01Xy__--  "
    "ABcd01Xy__--  " ) )

;;;; perl-584.retest/585: ([[:^digit:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/585"
  "([[:^digit:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "ABcd"
    "ABcd" ) )

;;;; perl-584.retest/586: ([[:^lower:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/586"
  "([[:^lower:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "AB"
    "AB" ) )

;;;; perl-584.retest/587: ([[:^print:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/587"
  "([[:^print:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    (backslash "\\u0000\\u0000\\u00FF\\u00FF")
    (backslash "\\u0000\\u0000\\u00FF\\u00FF") ) )

;;;; perl-584.retest/588: ([[:^punct:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/588"
  "([[:^punct:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "ABcd01Xy"
    "ABcd01Xy" ) )

;;;; perl-584.retest/589: ([[:^space:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/589"
  "([[:^space:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "ABcd01Xy__--"
    "ABcd01Xy__--" ) )

;;;; perl-584.retest/590: ([[:^word:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/590"
  "([[:^word:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    (backslash "--  \\u0000\\u0000\\u00FF\\u00FF")
    (backslash "--  \\u0000\\u0000\\u00FF\\u00FF") ) )

;;;; perl-584.retest/591: ([[:^upper:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/591"
  "([[:^upper:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    "cd01"
    "cd01" ) )

;;;; perl-584.retest/592: ([[:^xdigit:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/592"
  "([[:^xdigit:]]+)"
  (backslash "ABcd01Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
  '(:single-line nil)
  (list
    (backslash "Xy__--  \\u0000\\u0000\\u00FF\\u00FF")
    (backslash "Xy__--  \\u0000\\u0000\\u00FF\\u00FF") ) )

;;;; perl-584.retest/593: [[:foo:]]
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/593"
  "[[:foo:]]"
  "-"
  '(:single-line nil)
  :compile   ; POSIX class [:foo:] unknown
 )

;;;; perl-584.retest/594: [[:^foo:]]
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/594"
  "[[:^foo:]]"
  "-"
  '(:single-line nil)
  :compile   ; POSIX class [:^foo:] unknown
 )

;;;; perl-584.retest/595: ((?>a+)b)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/595"
  "((?>a+)b)"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "aaab" ) )

;;;; perl-584.retest/596: (?>(a+))b
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/596"
  "(?>(a+))b"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "aaa" ) )

;;;; perl-584.retest/597: ((?>[^()]+)|\([^()]*\))+
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/597"
  "((?>[^()]+)|\\([^()]*\\))+"
  "((abc(ade)ufh()()x"
  '(:single-line nil)
  (list
    "abc(ade)ufh()()x"
    "x" ) )

;;;; perl-584.retest/598: (?<=x+)y
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/598"
  "(?<=x+)y"
  "-"
  '(:single-line nil)
  :compile   ; Variable length lookbehind not implemented
 )

;;;; perl-584.retest/599: a{37,17}
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/599"
  "a{37,17}"
  "-"
  '(:single-line nil)
  :compile   ; Can't do {n,m} with n > m
 )

;;;; perl-584.retest/600: \Z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/600"
  "\\Z"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list "") )

;;;; perl-584.retest/601: \z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/601"
  "\\z"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list "") )

;;;; perl-584.retest/602: $
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/602"
  "$"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list "") )

;;;; perl-584.retest/603: \Z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/603"
  "\\Z"
  (backslash "b\\na\\n")
  '(:single-line nil)
  (list "") )

;;;; perl-584.retest/604: \z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/604"
  "\\z"
  (backslash "b\\na\\n")
  '(:single-line nil)
  (list "") )

;;;; perl-584.retest/605: $
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/605"
  "$"
  (backslash "b\\na\\n")
  '(:single-line nil)
  (list "") )

;;;; perl-584.retest/606: \Z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/606"
  "\\Z"
  (backslash "b\\na")
  '(:single-line nil)
  (list "") )

;;;; perl-584.retest/607: \z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/607"
  "\\z"
  (backslash "b\\na")
  '(:single-line nil)
  (list "") )

;;;; perl-584.retest/608: $
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/608"
  "$"
  (backslash "b\\na")
  '(:single-line nil)
  (list "") )

;;;; perl-584.retest/609: '\Z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/609"
  "\\Z"
  (backslash "a\\nb\\n")
  '(:multiple-lines t :single-line nil)
  (list "") )

;;;; perl-584.retest/610: '\z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/610"
  "\\z"
  (backslash "a\\nb\\n")
  '(:multiple-lines t :single-line nil)
  (list "") )

;;;; perl-584.retest/611: '$'m
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/611"
  "$"
  (backslash "a\\nb\\n")
  '(:multiple-lines t :single-line nil)
  (list "") )

;;;; perl-584.retest/612: '\Z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/612"
  "\\Z"
  (backslash "b\\na\\n")
  '(:multiple-lines t :single-line nil)
  (list "") )

;;;; perl-584.retest/613: '\z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/613"
  "\\z"
  (backslash "b\\na\\n")
  '(:multiple-lines t :single-line nil)
  (list "") )

;;;; perl-584.retest/614: '$'m
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/614"
  "$"
  (backslash "b\\na\\n")
  '(:multiple-lines t :single-line nil)
  (list "") )

;;;; perl-584.retest/615: '\Z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/615"
  "\\Z"
  (backslash "b\\na")
  '(:multiple-lines t :single-line nil)
  (list "") )

;;;; perl-584.retest/616: '\z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/616"
  "\\z"
  (backslash "b\\na")
  '(:multiple-lines t :single-line nil)
  (list "") )

;;;; perl-584.retest/617: '$'m
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/617"
  "$"
  (backslash "b\\na")
  '(:multiple-lines t :single-line nil)
  (list "") )

;;;; perl-584.retest/618: a\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/618"
  "a\\Z"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/619: a\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/619"
  "a\\z"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/620: a$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/620"
  "a$"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/621: a\Z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/621"
  "a\\Z"
  (backslash "b\\na\\n")
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/622: a\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/622"
  "a\\z"
  (backslash "b\\na\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/623: a$
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/623"
  "a$"
  (backslash "b\\na\\n")
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/624: a\Z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/624"
  "a\\Z"
  (backslash "b\\na")
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/625: a\z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/625"
  "a\\z"
  (backslash "b\\na")
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/626: a$
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/626"
  "a$"
  (backslash "b\\na")
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/627: 'a\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/627"
  "a\\Z"
  (backslash "a\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/628: 'a\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/628"
  "a\\z"
  (backslash "a\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/629: 'a$'m
;;;
;;;    Not mached. (y)
;
(test-case
  "perl-584/629"
  "a$"
  (backslash "a\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/630: 'a\Z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/630"
  "a\\Z"
  (backslash "b\\na\\n")
  '(:multiple-lines t :single-line nil)
  (list "a") )

;;;; perl-584.retest/631: 'a\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/631"
  "a\\z"
  (backslash "b\\na\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/632: 'a$'m
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/632"
  "a$"
  (backslash "b\\na\\n")
  '(:multiple-lines t :single-line nil)
  (list "a") )

;;;; perl-584.retest/633: 'a\Z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/633"
  "a\\Z"
  (backslash "b\\na")
  '(:multiple-lines t :single-line nil)
  (list "a") )

;;;; perl-584.retest/634: 'a\z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/634"
  "a\\z"
  (backslash "b\\na")
  '(:multiple-lines t :single-line nil)
  (list "a") )

;;;; perl-584.retest/635: 'a$'m
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/635"
  "a$"
  (backslash "b\\na")
  '(:multiple-lines t :single-line nil)
  (list "a") )

;;;; perl-584.retest/636: aa\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/636"
  "aa\\Z"
  (backslash "aa\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/637: aa\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/637"
  "aa\\z"
  (backslash "aa\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/638: aa$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/638"
  "aa$"
  (backslash "aa\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/639: aa\Z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/639"
  "aa\\Z"
  (backslash "b\\naa\\n")
  '(:single-line nil)
  (list "aa") )

;;;; perl-584.retest/640: aa\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/640"
  "aa\\z"
  (backslash "b\\naa\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/641: aa$
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/641"
  "aa$"
  (backslash "b\\naa\\n")
  '(:single-line nil)
  (list "aa") )

;;;; perl-584.retest/642: aa\Z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/642"
  "aa\\Z"
  (backslash "b\\naa")
  '(:single-line nil)
  (list "aa") )

;;;; perl-584.retest/643: aa\z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/643"
  "aa\\z"
  (backslash "b\\naa")
  '(:single-line nil)
  (list "aa") )

;;;; perl-584.retest/644: aa$
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/644"
  "aa$"
  (backslash "b\\naa")
  '(:single-line nil)
  (list "aa") )

;;;; perl-584.retest/645: 'aa\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/645"
  "aa\\Z"
  (backslash "aa\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/646: 'aa\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/646"
  "aa\\z"
  (backslash "aa\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/647: 'aa$'m
;;;
;;;    Not mached. (y)
;
(test-case
  "perl-584/647"
  "aa$"
  (backslash "aa\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/648: 'aa\Z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/648"
  "aa\\Z"
  (backslash "b\\naa\\n")
  '(:multiple-lines t :single-line nil)
  (list "aa") )

;;;; perl-584.retest/649: 'aa\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/649"
  "aa\\z"
  (backslash "b\\naa\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/650: 'aa$'m
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/650"
  "aa$"
  (backslash "b\\naa\\n")
  '(:multiple-lines t :single-line nil)
  (list "aa") )

;;;; perl-584.retest/651: 'aa\Z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/651"
  "aa\\Z"
  (backslash "b\\naa")
  '(:multiple-lines t :single-line nil)
  (list "aa") )

;;;; perl-584.retest/652: 'aa\z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/652"
  "aa\\z"
  (backslash "b\\naa")
  '(:multiple-lines t :single-line nil)
  (list "aa") )

;;;; perl-584.retest/653: 'aa$'m
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/653"
  "aa$"
  (backslash "b\\naa")
  '(:multiple-lines t :single-line nil)
  (list "aa") )

;;;; perl-584.retest/654: aa\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/654"
  "aa\\Z"
  (backslash "ac\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/655: aa\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/655"
  "aa\\z"
  (backslash "ac\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/656: aa$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/656"
  "aa$"
  (backslash "ac\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/657: aa\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/657"
  "aa\\Z"
  (backslash "b\\nac\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/658: aa\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/658"
  "aa\\z"
  (backslash "b\\nac\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/659: aa$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/659"
  "aa$"
  (backslash "b\\nac\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/660: aa\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/660"
  "aa\\Z"
  (backslash "b\\nac")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/661: aa\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/661"
  "aa\\z"
  (backslash "b\\nac")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/662: aa$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/662"
  "aa$"
  (backslash "b\\nac")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/663: 'aa\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/663"
  "aa\\Z"
  (backslash "ac\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/664: 'aa\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/664"
  "aa\\z"
  (backslash "ac\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/665: 'aa$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/665"
  "aa$"
  (backslash "ac\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/666: 'aa\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/666"
  "aa\\Z"
  (backslash "b\\nac\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/667: 'aa\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/667"
  "aa\\z"
  (backslash "b\\nac\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/668: 'aa$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/668"
  "aa$"
  (backslash "b\\nac\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/669: 'aa\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/669"
  "aa\\Z"
  (backslash "b\\nac")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/670: 'aa\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/670"
  "aa\\z"
  (backslash "b\\nac")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/671: 'aa$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/671"
  "aa$"
  (backslash "b\\nac")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/672: aa\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/672"
  "aa\\Z"
  (backslash "ca\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/673: aa\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/673"
  "aa\\z"
  (backslash "ca\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/674: aa$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/674"
  "aa$"
  (backslash "ca\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/675: aa\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/675"
  "aa\\Z"
  (backslash "b\\nca\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/676: aa\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/676"
  "aa\\z"
  (backslash "b\\nca\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/677: aa$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/677"
  "aa$"
  (backslash "b\\nca\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/678: aa\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/678"
  "aa\\Z"
  (backslash "b\\nca")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/679: aa\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/679"
  "aa\\z"
  (backslash "b\\nca")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/680: aa$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/680"
  "aa$"
  (backslash "b\\nca")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/681: 'aa\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/681"
  "aa\\Z"
  (backslash "ca\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/682: 'aa\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/682"
  "aa\\z"
  (backslash "ca\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/683: 'aa$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/683"
  "aa$"
  (backslash "ca\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/684: 'aa\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/684"
  "aa\\Z"
  (backslash "b\\nca\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/685: 'aa\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/685"
  "aa\\z"
  (backslash "b\\nca\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/686: 'aa$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/686"
  "aa$"
  (backslash "b\\nca\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/687: 'aa\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/687"
  "aa\\Z"
  (backslash "b\\nca")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/688: 'aa\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/688"
  "aa\\z"
  (backslash "b\\nca")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/689: 'aa$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/689"
  "aa$"
  (backslash "b\\nca")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/690: ab\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/690"
  "ab\\Z"
  (backslash "ab\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/691: ab\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/691"
  "ab\\z"
  (backslash "ab\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/692: ab$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/692"
  "ab$"
  (backslash "ab\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/693: ab\Z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/693"
  "ab\\Z"
  (backslash "b\\nab\\n")
  '(:single-line nil)
  (list "ab") )

;;;; perl-584.retest/694: ab\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/694"
  "ab\\z"
  (backslash "b\\nab\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/695: ab$
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/695"
  "ab$"
  (backslash "b\\nab\\n")
  '(:single-line nil)
  (list "ab") )

;;;; perl-584.retest/696: ab\Z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/696"
  "ab\\Z"
  (backslash "b\\nab")
  '(:single-line nil)
  (list "ab") )

;;;; perl-584.retest/697: ab\z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/697"
  "ab\\z"
  (backslash "b\\nab")
  '(:single-line nil)
  (list "ab") )

;;;; perl-584.retest/698: ab$
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/698"
  "ab$"
  (backslash "b\\nab")
  '(:single-line nil)
  (list "ab") )

;;;; perl-584.retest/699: 'ab\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/699"
  "ab\\Z"
  (backslash "ab\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/700: 'ab\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/700"
  "ab\\z"
  (backslash "ab\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/701: 'ab$'m
;;;
;;;    Not mached. (y)
;
(test-case
  "perl-584/701"
  "ab$"
  (backslash "ab\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/702: 'ab\Z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/702"
  "ab\\Z"
  (backslash "b\\nab\\n")
  '(:multiple-lines t :single-line nil)
  (list "ab") )

;;;; perl-584.retest/703: 'ab\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/703"
  "ab\\z"
  (backslash "b\\nab\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/704: 'ab$'m
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/704"
  "ab$"
  (backslash "b\\nab\\n")
  '(:multiple-lines t :single-line nil)
  (list "ab") )

;;;; perl-584.retest/705: 'ab\Z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/705"
  "ab\\Z"
  (backslash "b\\nab")
  '(:multiple-lines t :single-line nil)
  (list "ab") )

;;;; perl-584.retest/706: 'ab\z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/706"
  "ab\\z"
  (backslash "b\\nab")
  '(:multiple-lines t :single-line nil)
  (list "ab") )

;;;; perl-584.retest/707: 'ab$'m
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/707"
  "ab$"
  (backslash "b\\nab")
  '(:multiple-lines t :single-line nil)
  (list "ab") )

;;;; perl-584.retest/708: ab\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/708"
  "ab\\Z"
  (backslash "ac\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/709: ab\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/709"
  "ab\\z"
  (backslash "ac\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/710: ab$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/710"
  "ab$"
  (backslash "ac\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/711: ab\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/711"
  "ab\\Z"
  (backslash "b\\nac\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/712: ab\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/712"
  "ab\\z"
  (backslash "b\\nac\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/713: ab$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/713"
  "ab$"
  (backslash "b\\nac\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/714: ab\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/714"
  "ab\\Z"
  (backslash "b\\nac")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/715: ab\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/715"
  "ab\\z"
  (backslash "b\\nac")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/716: ab$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/716"
  "ab$"
  (backslash "b\\nac")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/717: 'ab\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/717"
  "ab\\Z"
  (backslash "ac\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/718: 'ab\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/718"
  "ab\\z"
  (backslash "ac\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/719: 'ab$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/719"
  "ab$"
  (backslash "ac\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/720: 'ab\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/720"
  "ab\\Z"
  (backslash "b\\nac\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/721: 'ab\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/721"
  "ab\\z"
  (backslash "b\\nac\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/722: 'ab$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/722"
  "ab$"
  (backslash "b\\nac\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/723: 'ab\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/723"
  "ab\\Z"
  (backslash "b\\nac")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/724: 'ab\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/724"
  "ab\\z"
  (backslash "b\\nac")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/725: 'ab$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/725"
  "ab$"
  (backslash "b\\nac")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/726: ab\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/726"
  "ab\\Z"
  (backslash "ca\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/727: ab\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/727"
  "ab\\z"
  (backslash "ca\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/728: ab$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/728"
  "ab$"
  (backslash "ca\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/729: ab\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/729"
  "ab\\Z"
  (backslash "b\\nca\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/730: ab\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/730"
  "ab\\z"
  (backslash "b\\nca\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/731: ab$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/731"
  "ab$"
  (backslash "b\\nca\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/732: ab\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/732"
  "ab\\Z"
  (backslash "b\\nca")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/733: ab\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/733"
  "ab\\z"
  (backslash "b\\nca")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/734: ab$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/734"
  "ab$"
  (backslash "b\\nca")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/735: 'ab\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/735"
  "ab\\Z"
  (backslash "ca\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/736: 'ab\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/736"
  "ab\\z"
  (backslash "ca\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/737: 'ab$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/737"
  "ab$"
  (backslash "ca\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/738: 'ab\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/738"
  "ab\\Z"
  (backslash "b\\nca\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/739: 'ab\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/739"
  "ab\\z"
  (backslash "b\\nca\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/740: 'ab$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/740"
  "ab$"
  (backslash "b\\nca\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/741: 'ab\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/741"
  "ab\\Z"
  (backslash "b\\nca")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/742: 'ab\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/742"
  "ab\\z"
  (backslash "b\\nca")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/743: 'ab$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/743"
  "ab$"
  (backslash "b\\nca")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/744: abb\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/744"
  "abb\\Z"
  (backslash "abb\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/745: abb\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/745"
  "abb\\z"
  (backslash "abb\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/746: abb$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/746"
  "abb$"
  (backslash "abb\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/747: abb\Z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/747"
  "abb\\Z"
  (backslash "b\\nabb\\n")
  '(:single-line nil)
  (list "abb") )

;;;; perl-584.retest/748: abb\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/748"
  "abb\\z"
  (backslash "b\\nabb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/749: abb$
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/749"
  "abb$"
  (backslash "b\\nabb\\n")
  '(:single-line nil)
  (list "abb") )

;;;; perl-584.retest/750: abb\Z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/750"
  "abb\\Z"
  (backslash "b\\nabb")
  '(:single-line nil)
  (list "abb") )

;;;; perl-584.retest/751: abb\z
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/751"
  "abb\\z"
  (backslash "b\\nabb")
  '(:single-line nil)
  (list "abb") )

;;;; perl-584.retest/752: abb$
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/752"
  "abb$"
  (backslash "b\\nabb")
  '(:single-line nil)
  (list "abb") )

;;;; perl-584.retest/753: 'abb\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/753"
  "abb\\Z"
  (backslash "abb\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/754: 'abb\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/754"
  "abb\\z"
  (backslash "abb\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/755: 'abb$'m
;;;
;;;    Not mached. (y)
;
(test-case
  "perl-584/755"
  "abb$"
  (backslash "abb\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/756: 'abb\Z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/756"
  "abb\\Z"
  (backslash "b\\nabb\\n")
  '(:multiple-lines t :single-line nil)
  (list "abb") )

;;;; perl-584.retest/757: 'abb\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/757"
  "abb\\z"
  (backslash "b\\nabb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/758: 'abb$'m
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/758"
  "abb$"
  (backslash "b\\nabb\\n")
  '(:multiple-lines t :single-line nil)
  (list "abb") )

;;;; perl-584.retest/759: 'abb\Z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/759"
  "abb\\Z"
  (backslash "b\\nabb")
  '(:multiple-lines t :single-line nil)
  (list "abb") )

;;;; perl-584.retest/760: 'abb\z'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/760"
  "abb\\z"
  (backslash "b\\nabb")
  '(:multiple-lines t :single-line nil)
  (list "abb") )

;;;; perl-584.retest/761: 'abb$'m
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/761"
  "abb$"
  (backslash "b\\nabb")
  '(:multiple-lines t :single-line nil)
  (list "abb") )

;;;; perl-584.retest/762: abb\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/762"
  "abb\\Z"
  (backslash "ac\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/763: abb\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/763"
  "abb\\z"
  (backslash "ac\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/764: abb$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/764"
  "abb$"
  (backslash "ac\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/765: abb\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/765"
  "abb\\Z"
  (backslash "b\\nac\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/766: abb\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/766"
  "abb\\z"
  (backslash "b\\nac\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/767: abb$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/767"
  "abb$"
  (backslash "b\\nac\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/768: abb\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/768"
  "abb\\Z"
  (backslash "b\\nac")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/769: abb\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/769"
  "abb\\z"
  (backslash "b\\nac")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/770: abb$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/770"
  "abb$"
  (backslash "b\\nac")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/771: 'abb\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/771"
  "abb\\Z"
  (backslash "ac\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/772: 'abb\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/772"
  "abb\\z"
  (backslash "ac\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/773: 'abb$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/773"
  "abb$"
  (backslash "ac\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/774: 'abb\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/774"
  "abb\\Z"
  (backslash "b\\nac\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/775: 'abb\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/775"
  "abb\\z"
  (backslash "b\\nac\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/776: 'abb$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/776"
  "abb$"
  (backslash "b\\nac\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/777: 'abb\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/777"
  "abb\\Z"
  (backslash "b\\nac")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/778: 'abb\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/778"
  "abb\\z"
  (backslash "b\\nac")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/779: 'abb$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/779"
  "abb$"
  (backslash "b\\nac")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/780: abb\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/780"
  "abb\\Z"
  (backslash "ca\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/781: abb\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/781"
  "abb\\z"
  (backslash "ca\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/782: abb$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/782"
  "abb$"
  (backslash "ca\\nb\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/783: abb\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/783"
  "abb\\Z"
  (backslash "b\\nca\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/784: abb\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/784"
  "abb\\z"
  (backslash "b\\nca\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/785: abb$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/785"
  "abb$"
  (backslash "b\\nca\\n")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/786: abb\Z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/786"
  "abb\\Z"
  (backslash "b\\nca")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/787: abb\z
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/787"
  "abb\\z"
  (backslash "b\\nca")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/788: abb$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/788"
  "abb$"
  (backslash "b\\nca")
  '(:single-line nil)
  nil )

;;;; perl-584.retest/789: 'abb\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/789"
  "abb\\Z"
  (backslash "ca\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/790: 'abb\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/790"
  "abb\\z"
  (backslash "ca\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/791: 'abb$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/791"
  "abb$"
  (backslash "ca\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/792: 'abb\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/792"
  "abb\\Z"
  (backslash "b\\nca\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/793: 'abb\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/793"
  "abb\\z"
  (backslash "b\\nca\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/794: 'abb$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/794"
  "abb$"
  (backslash "b\\nca\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/795: 'abb\Z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/795"
  "abb\\Z"
  (backslash "b\\nca")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/796: 'abb\z'm
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/796"
  "abb\\z"
  (backslash "b\\nca")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/797: 'abb$'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/797"
  "abb$"
  (backslash "b\\nca")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/798: (^|x)(c)
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/798"
  "(^|x)(c)"
  "ca"
  '(:single-line nil)
  (list
    "c"
    ""
    "c" ) )

;;;; perl-584.retest/799: a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/799"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "x"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/800: a(?{$a=2;$b=3;($b)=$a})b
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/800"
  "a(?{$a=2;$b=3;($b)=$a})b"
  "yabz"
  '(:single-line nil)
  (list "ab") )

;;;; perl-584.retest/801: round\(((?>[^()]+))\)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/801"
  "round\\(((?>[^()]+))\\)"
  "_I(round(xs * sz),1)"
  '(:single-line nil)
  (list
    "round(xs * sz)"
    "xs * sz" ) )

;;;; perl-584.retest/802: '((?x:.) )'
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/802"
  "((?x:.) )"
  "x "
  '(:single-line nil)
  (list
    "x "
    "x " ) )

;;;; perl-584.retest/803: '((?-x:.) )'x
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/803"
  "((?-x:.) )"
  "x "
  '(:extended-syntax t :single-line nil)
  (list
    "x"
    "x" ) )

;;;; perl-584.retest/804: foo.bart
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/804"
  "foo.bart"
  "foo.bart"
  '(:single-line nil)
  (list "foo.bart") )

;;;; perl-584.retest/805: '^d[x][x][x]'m
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/805"
  "^d[x][x][x]"
  (backslash "abcd\\ndxxx")
  '(:multiple-lines t :single-line nil)
  (list "dxxx") )

;;;; perl-584.retest/806: .X(.+)+X
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/806"
  ".X(.+)+X"
  "bbbbXcXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  (list
    "bXcX"
    "c" ) )

;;;; perl-584.retest/807: .X(.+)+XX
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/807"
  ".X(.+)+XX"
  "bbbbXcXXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  (list
    "bXcXX"
    "c" ) )

;;;; perl-584.retest/808: .XX(.+)+X
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/808"
  ".XX(.+)+X"
  "bbbbXXcXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  (list
    "bXXcX"
    "c" ) )

;;;; perl-584.retest/809: .X(.+)+X
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/809"
  ".X(.+)+X"
  "bbbbXXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/810: .X(.+)+XX
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/810"
  ".X(.+)+XX"
  "bbbbXXXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/811: .XX(.+)+X
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/811"
  ".XX(.+)+X"
  "bbbbXXXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/812: .X(.+)+[X]
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/812"
  ".X(.+)+[X]"
  "bbbbXcXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  (list
    "bXcX"
    "c" ) )

;;;; perl-584.retest/813: .X(.+)+[X][X]
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/813"
  ".X(.+)+[X][X]"
  "bbbbXcXXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  (list
    "bXcXX"
    "c" ) )

;;;; perl-584.retest/814: .XX(.+)+[X]
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/814"
  ".XX(.+)+[X]"
  "bbbbXXcXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  (list
    "bXXcX"
    "c" ) )

;;;; perl-584.retest/815: .X(.+)+[X]
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/815"
  ".X(.+)+[X]"
  "bbbbXXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/816: .X(.+)+[X][X]
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/816"
  ".X(.+)+[X][X]"
  "bbbbXXXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/817: .XX(.+)+[X]
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/817"
  ".XX(.+)+[X]"
  "bbbbXXXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/818: .[X](.+)+[X]
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/818"
  ".[X](.+)+[X]"
  "bbbbXcXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  (list
    "bXcX"
    "c" ) )

;;;; perl-584.retest/819: .[X](.+)+[X][X]
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/819"
  ".[X](.+)+[X][X]"
  "bbbbXcXXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  (list
    "bXcXX"
    "c" ) )

;;;; perl-584.retest/820: .[X][X](.+)+[X]
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/820"
  ".[X][X](.+)+[X]"
  "bbbbXXcXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  (list
    "bXXcX"
    "c" ) )

;;;; perl-584.retest/821: .[X](.+)+[X]
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/821"
  ".[X](.+)+[X]"
  "bbbbXXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/822: .[X](.+)+[X][X]
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/822"
  ".[X](.+)+[X][X]"
  "bbbbXXXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/823: .[X][X](.+)+[X]
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/823"
  ".[X][X](.+)+[X]"
  "bbbbXXXaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/824: tt+$
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/824"
  "tt+$"
  "xxxtt"
  '(:single-line nil)
  (list "tt") )

;;;; perl-584.retest/825: ([a-\d]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/825"
  "([a-\\d]+)"
  "za-9z"
  '(:single-line nil)
  (list
    "a-9"
    "a-9" ) )

;;;; perl-584.retest/826: ([\d-z]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/826"
  "([\\d-z]+)"
  "a0-za"
  '(:single-line nil)
  (list
    "0-z"
    "0-z" ) )

;;;; perl-584.retest/827: ([\d-\s]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/827"
  "([\\d-\\s]+)"
  "a0- z"
  '(:single-line nil)
  (list
    "0- "
    "0- " ) )

;;;; perl-584.retest/828: ([a-[:digit:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/828"
  "([a-[:digit:]]+)"
  "za-9z"
  '(:single-line nil)
  (list
    "a-9"
    "a-9" ) )

;;;; perl-584.retest/829: ([[:digit:]-z]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/829"
  "([[:digit:]-z]+)"
  "=0-z="
  '(:single-line nil)
  (list
    "0-z"
    "0-z" ) )

;;;; perl-584.retest/830: ([[:digit:]-[:alpha:]]+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/830"
  "([[:digit:]-[:alpha:]]+)"
  "=0-z="
  '(:single-line nil)
  (list
    "0-z"
    "0-z" ) )

;;;; perl-584.retest/831: \GX.*X
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/831"
  "\\GX.*X"
  "aaaXbX"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/832: (\d+\.\d+)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/832"
  "(\\d+\\.\\d+)"
  "3.1415926"
  '(:single-line nil)
  (list
    "3.1415926"
    "3.1415926" ) )

;;;; perl-584.retest/833: (\ba.{0,10}br)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/833"
  "(\\ba.{0,10}br)"
  "have a web browser"
  '(:single-line nil)
  (list
    "a web br"
    "a web br" ) )

;;;; perl-584.retest/834: '\.c(pp|xx|c)?$'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/834"
  "\\.c(pp|xx|c)?$"
  "Changes"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/835: '\.c(pp|xx|c)?$'i
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/835"
  "\\.c(pp|xx|c)?$"
  "IO.c"
  '(:ignore-case t :single-line nil)
  (list ".c") )

;;;; perl-584.retest/836: '(\.c(pp|xx|c)?$)'i
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/836"
  "(\\.c(pp|xx|c)?$)"
  "IO.c"
  '(:ignore-case t :single-line nil)
  (list
    ".c"
    ".c" ) )

;;;; perl-584.retest/837: ^([a-z]:)
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/837"
  "^([a-z]:)"
  "C:/"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/838: '^\S\s+aa$'m
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/838"
  "^\\S\\s+aa$"
  (backslash "\\nx aa")
  '(:multiple-lines t :single-line nil)
  (list "x aa") )

;;;; perl-584.retest/839: (^|a)b
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/839"
  "(^|a)b"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "a" ) )

;;;; perl-584.retest/840: ^([ab]*?)(b)?(c)$
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-584/840"
  "^([ab]*?)(b)?(c)$"
  "abac"
  '(:single-line nil)
  (list
    "abac"
    "aba"
    nil
    "c" ) )

;;;; perl-584.retest/841: (\w)?(abc)\1b
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/841"
  "(\\w)?(abc)\\1b"
  "abcab"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/842: ^(?:.,){2}c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/842"
  "^(?:.,){2}c"
  "a,b,c"
  '(:single-line nil)
  (list "a,b,c") )

;;;; perl-584.retest/843: ^(.,){2}c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/843"
  "^(.,){2}c"
  "a,b,c"
  '(:single-line nil)
  (list
    "a,b,c"
    "b," ) )

;;;; perl-584.retest/844: ^(?:[^,]*,){2}c
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/844"
  "^(?:[^,]*,){2}c"
  "a,b,c"
  '(:single-line nil)
  (list "a,b,c") )

;;;; perl-584.retest/845: ^([^,]*,){2}c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/845"
  "^([^,]*,){2}c"
  "a,b,c"
  '(:single-line nil)
  (list
    "a,b,c"
    "b," ) )

;;;; perl-584.retest/846: ^([^,]*,){3}d
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/846"
  "^([^,]*,){3}d"
  "aaa,b,c,d"
  '(:single-line nil)
  (list
    "aaa,b,c,d"
    "c," ) )

;;;; perl-584.retest/847: ^([^,]*,){3,}d
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/847"
  "^([^,]*,){3,}d"
  "aaa,b,c,d"
  '(:single-line nil)
  (list
    "aaa,b,c,d"
    "c," ) )

;;;; perl-584.retest/848: ^([^,]*,){0,3}d
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/848"
  "^([^,]*,){0,3}d"
  "aaa,b,c,d"
  '(:single-line nil)
  (list
    "aaa,b,c,d"
    "c," ) )

;;;; perl-584.retest/849: ^([^,]{1,3},){3}d
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/849"
  "^([^,]{1,3},){3}d"
  "aaa,b,c,d"
  '(:single-line nil)
  (list
    "aaa,b,c,d"
    "c," ) )

;;;; perl-584.retest/850: ^([^,]{1,3},){3,}d
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/850"
  "^([^,]{1,3},){3,}d"
  "aaa,b,c,d"
  '(:single-line nil)
  (list
    "aaa,b,c,d"
    "c," ) )

;;;; perl-584.retest/851: ^([^,]{1,3},){0,3}d
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/851"
  "^([^,]{1,3},){0,3}d"
  "aaa,b,c,d"
  '(:single-line nil)
  (list
    "aaa,b,c,d"
    "c," ) )

;;;; perl-584.retest/852: ^([^,]{1,},){3}d
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/852"
  "^([^,]{1,},){3}d"
  "aaa,b,c,d"
  '(:single-line nil)
  (list
    "aaa,b,c,d"
    "c," ) )

;;;; perl-584.retest/853: ^([^,]{1,},){3,}d
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/853"
  "^([^,]{1,},){3,}d"
  "aaa,b,c,d"
  '(:single-line nil)
  (list
    "aaa,b,c,d"
    "c," ) )

;;;; perl-584.retest/854: ^([^,]{1,},){0,3}d
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/854"
  "^([^,]{1,},){0,3}d"
  "aaa,b,c,d"
  '(:single-line nil)
  (list
    "aaa,b,c,d"
    "c," ) )

;;;; perl-584.retest/855: ^([^,]{0,3},){3}d
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/855"
  "^([^,]{0,3},){3}d"
  "aaa,b,c,d"
  '(:single-line nil)
  (list
    "aaa,b,c,d"
    "c," ) )

;;;; perl-584.retest/856: ^([^,]{0,3},){3,}d
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/856"
  "^([^,]{0,3},){3,}d"
  "aaa,b,c,d"
  '(:single-line nil)
  (list
    "aaa,b,c,d"
    "c," ) )

;;;; perl-584.retest/857: ^([^,]{0,3},){0,3}d
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/857"
  "^([^,]{0,3},){0,3}d"
  "aaa,b,c,d"
  '(:single-line nil)
  (list
    "aaa,b,c,d"
    "c," ) )

;;;; perl-584.retest/858: (?i)
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/858"
  "(?i)"
  ""
  '(:single-line nil)
  (list "") )

;;;; perl-584.retest/859: '(?!\A)x'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/859"
  "(?!\\A)x"
  (backslash "a\\nxb\\n")
  '(:multiple-lines t :single-line nil)
  (list "x") )

;;;; perl-584.retest/860: ^(a(b)?)+$
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/860"
  "^(a(b)?)+$"
  "aba"
  '(:single-line nil)
  (list
    "aba"
    "a"
    nil ) )

;;;; perl-584.retest/861: ^(aa(bb)?)+$
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/861"
  "^(aa(bb)?)+$"
  "aabbaa"
  '(:single-line nil)
  (list
    "aabbaa"
    "aa"
    nil ) )

;;;; perl-584.retest/862: '^.{9}abc.*\n'm
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/862"
  "^.{9}abc.*
"
  (backslash "123\\nabcabcabcabc\\n")
  '(:multiple-lines t :single-line nil)
  (list "abcabcabcabc
") )

;;;; perl-584.retest/863: ^(a)?a$
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/863"
  "^(a)?a$"
  "a"
  '(:single-line nil)
  (list
    "a"
    nil ) )

;;;; perl-584.retest/864: ^(a)?(?(1)a|b)+$
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/864"
  "^(a)?(?(1)a|b)+$"
  "a"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/865: ^(a\1?)(a\1?)(a\2?)(a\3?)$
;;;
;;;    Matched with 4 captures. (y)
;
(test-case
  "perl-584/865"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaa"
  '(:single-line nil)
  (list
    "aaaaaa"
    "a"
    "aa"
    "a"
    "aa" ) )

;;;; perl-584.retest/866: ^(a\1?){4}$
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/866"
  "^(a\\1?){4}$"
  "aaaaaa"
  '(:single-line nil)
  (list
    "aaaaaa"
    "aa" ) )

;;;; perl-584.retest/867: ^(0+)?(?:x(1))?
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/867"
  "^(0+)?(?:x(1))?"
  "x1"
  '(:single-line nil)
  (list
    "x1"
    nil
    "1" ) )

;;;; perl-584.retest/868: ^([0-9a-fA-F]+)(?:x([0-9a-fA-F]+)?)(?:x([0-9a-fA-F]+))?
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-584/868"
  "^([0-9a-fA-F]+)(?:x([0-9a-fA-F]+)?)(?:x([0-9a-fA-F]+))?"
  "012cxx0190"
  '(:single-line nil)
  (list
    "012cxx0190"
    "012c"
    nil
    "0190" ) )

;;;; perl-584.retest/869: ^(b+?|a){1,2}c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/869"
  "^(b+?|a){1,2}c"
  "bbbac"
  '(:single-line nil)
  (list
    "bbbac"
    "a" ) )

;;;; perl-584.retest/870: ^(b+?|a){1,2}c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/870"
  "^(b+?|a){1,2}c"
  "bbbbac"
  '(:single-line nil)
  (list
    "bbbbac"
    "a" ) )

;;;; perl-584.retest/871: \((\w\. \w+)\)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/871"
  "\\((\\w\\. \\w+)\\)"
  "cd. (A. Tw)"
  '(:single-line nil)
  (list
    "(A. Tw)"
    "A. Tw" ) )

;;;; perl-584.retest/872: ((?:aaaa|bbbb)cccc)?
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/872"
  "((?:aaaa|bbbb)cccc)?"
  "aaaacccc"
  '(:single-line nil)
  (list
    "aaaacccc"
    "aaaacccc" ) )

;;;; perl-584.retest/873: ((?:aaaa|bbbb)cccc)?
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/873"
  "((?:aaaa|bbbb)cccc)?"
  "bbbbcccc"
  '(:single-line nil)
  (list
    "bbbbcccc"
    "bbbbcccc" ) )

;;;; perl-584.retest/874: (a)?(a)+
;;;
;;;    Matched with 2 captures. (y)
;
(test-case    ; -
  "perl-584/874"
  "(a)?(a)+"
  "a"
  '(:single-line nil)
  (list
    "a"
    nil
    "a" ) )

;;;; perl-584.retest/875: (ab)?(ab)+
;;;
;;;    Matched with 2 captures. (y)
;
(test-case    ; -
  "perl-584/875"
  "(ab)?(ab)+"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    nil
    "ab" ) )

;;;; perl-584.retest/876: (abc)?(abc)+
;;;
;;;    Matched with 2 captures. (y)
;
(test-case    ; -
  "perl-584/876"
  "(abc)?(abc)+"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    nil
    "abc" ) )

;;;; perl-584.retest/877: 'b\s^'m
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/877"
  "b\\s^"
  (backslash "a\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil )

;;;; perl-584.retest/878: \ba
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/878"
  "\\ba"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; perl-584.retest/879: ^(a(??{"(?!)"})|(a)(?{1}))b
;;;
;;;    Matched with 2 captures. (y)
;
(test-case    ; # [ID 20010811.006]
  "perl-584/879"
  "^(a(??{\"(?!)\"})|(a)(?{1}))b"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "a"
    "a" ) )

;;;; perl-584.retest/880: ab(?i)cd
;;;
;;;    Not mached. (n)
;
(test-case    ; # [ID 20010809.023]
  "perl-584/880"
  "ab(?i)cd"
  "AbCd"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/881: ab(?i)cd
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/881"
  "ab(?i)cd"
  "abCd"
  '(:single-line nil)
  (list "abCd") )

;;;; perl-584.retest/882: (A|B)*(?(1)(CD)|(CD))
;;;
;;;    Matched with 3 captures. (y)
;
(test-case
  "perl-584/882"
  "(A|B)*(?(1)(CD)|(CD))"
  "CD"
  '(:single-line nil)
  (list
    "CD"
    nil
    nil
    "CD" ) )

;;;; perl-584.retest/883: (A|B)*(?(1)(CD)|(CD))
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/883"
  "(A|B)*(?(1)(CD)|(CD))"
  "ABCD"
  '(:single-line nil)
  (list
    "ABCD"
    "B"
    "CD" ) )

;;;; perl-584.retest/884: (A|B)*?(?(1)(CD)|(CD))
;;;
;;;    Matched with 3 captures. (y)
;
(test-case    ; # [ID 20010803.016]
  "perl-584/884"
  "(A|B)*?(?(1)(CD)|(CD))"
  "CD"
  '(:single-line nil)
  (list
    "CD"
    nil
    nil
    "CD" ) )

;;;; perl-584.retest/885: (A|B)*?(?(1)(CD)|(CD))
;;;
;;;    Matched with 2 captures. (y)
;
(test-case
  "perl-584/885"
  "(A|B)*?(?(1)(CD)|(CD))"
  "ABCD"
  '(:single-line nil)
  (list
    "ABCD"
    "B"
    "CD" ) )

;;;; perl-584.retest/886: '^(o)(?!.*\1)'i
;;;
;;;    Not mached. (n)
;
(test-case
  "perl-584/886"
  "^(o)(?!.*\\1)"
  "Oo"
  '(:ignore-case t :single-line nil)
  nil )

;;;; perl-584.retest/887: (.*)\d+\1
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/887"
  "(.*)\\d+\\1"
  "abc12bc"
  '(:single-line nil)
  (list
    "bc12bc"
    "bc" ) )

;;;; perl-584.retest/888: (?m:(foo\s*$))
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/888"
  "(?m:(foo\\s*$))"
  (backslash "foo\\n bar")
  '(:single-line nil)
  (list
    "foo"
    "foo" ) )

;;;; perl-584.retest/889: (.*)c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/889"
  "(.*)c"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/890: (.*)(?=c)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/890"
  "(.*)(?=c)"
  "abcd"
  '(:single-line nil)
  (list
    "ab"
    "ab" ) )

;;;; perl-584.retest/891: (.*)(?=c)c
;;;
;;;    Expect is NOT true due to bug of Perl. (yB)
;
(test-case
  "perl-584/891"
  "(.*)(?=c)c"
  "abcd"
  '(:single-line nil)
  (list
    "c"
    "" ) )

;;;; perl-584.retest/892: (.*)(?=b|c)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/892"
  "(.*)(?=b|c)"
  "abcd"
  '(:single-line nil)
  (list
    "ab"
    "ab" ) )

;;;; perl-584.retest/893: (.*)(?=b|c)c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/893"
  "(.*)(?=b|c)c"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/894: (.*)(?=c|b)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/894"
  "(.*)(?=c|b)"
  "abcd"
  '(:single-line nil)
  (list
    "ab"
    "ab" ) )

;;;; perl-584.retest/895: (.*)(?=c|b)c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/895"
  "(.*)(?=c|b)c"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/896: (.*)(?=[bc])
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/896"
  "(.*)(?=[bc])"
  "abcd"
  '(:single-line nil)
  (list
    "ab"
    "ab" ) )

;;;; perl-584.retest/897: (.*)(?=[bc])c
;;;
;;;    Expect is NOT true due to bug of Perl. (yB)
;
(test-case
  "perl-584/897"
  "(.*)(?=[bc])c"
  "abcd"
  '(:single-line nil)
  (list
    "bc"
    "b" ) )

;;;; perl-584.retest/898: (.*)(?<=b)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/898"
  "(.*)(?<=b)"
  "abcd"
  '(:single-line nil)
  (list
    "ab"
    "ab" ) )

;;;; perl-584.retest/899: (.*)(?<=b)c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/899"
  "(.*)(?<=b)c"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/900: (.*)(?<=b|c)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/900"
  "(.*)(?<=b|c)"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "abc" ) )

;;;; perl-584.retest/901: (.*)(?<=b|c)c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/901"
  "(.*)(?<=b|c)c"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/902: (.*)(?<=c|b)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/902"
  "(.*)(?<=c|b)"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "abc" ) )

;;;; perl-584.retest/903: (.*)(?<=c|b)c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/903"
  "(.*)(?<=c|b)c"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/904: (.*)(?<=[bc])
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/904"
  "(.*)(?<=[bc])"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "abc" ) )

;;;; perl-584.retest/905: (.*)(?<=[bc])c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/905"
  "(.*)(?<=[bc])c"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/906: (.*?)c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/906"
  "(.*?)c"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/907: (.*?)(?=c)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/907"
  "(.*?)(?=c)"
  "abcd"
  '(:single-line nil)
  (list
    "ab"
    "ab" ) )

;;;; perl-584.retest/908: (.*?)(?=c)c
;;;
;;;    Expect is NOT true due to bug of Perl. (yB)
;
(test-case
  "perl-584/908"
  "(.*?)(?=c)c"
  "abcd"
  '(:single-line nil)
  (list
    "c"
    "" ) )

;;;; perl-584.retest/909: (.*?)(?=b|c)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/909"
  "(.*?)(?=b|c)"
  "abcd"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; perl-584.retest/910: (.*?)(?=b|c)c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/910"
  "(.*?)(?=b|c)c"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/911: (.*?)(?=c|b)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/911"
  "(.*?)(?=c|b)"
  "abcd"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; perl-584.retest/912: (.*?)(?=c|b)c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/912"
  "(.*?)(?=c|b)c"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/913: (.*?)(?=[bc])
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/913"
  "(.*?)(?=[bc])"
  "abcd"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; perl-584.retest/914: (.*?)(?=[bc])c
;;;
;;;    Expect is NOT true due to bug of Perl. (yB)
;
(test-case
  "perl-584/914"
  "(.*?)(?=[bc])c"
  "abcd"
  '(:single-line nil)
  (list
    "bc"
    "b" ) )

;;;; perl-584.retest/915: (.*?)(?<=b)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/915"
  "(.*?)(?<=b)"
  "abcd"
  '(:single-line nil)
  (list
    "ab"
    "ab" ) )

;;;; perl-584.retest/916: (.*?)(?<=b)c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/916"
  "(.*?)(?<=b)c"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/917: (.*?)(?<=b|c)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/917"
  "(.*?)(?<=b|c)"
  "abcd"
  '(:single-line nil)
  (list
    "ab"
    "ab" ) )

;;;; perl-584.retest/918: (.*?)(?<=b|c)c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/918"
  "(.*?)(?<=b|c)c"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/919: (.*?)(?<=c|b)
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/919"
  "(.*?)(?<=c|b)"
  "abcd"
  '(:single-line nil)
  (list
    "ab"
    "ab" ) )

;;;; perl-584.retest/920: (.*?)(?<=c|b)c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/920"
  "(.*?)(?<=c|b)c"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/921: (.*?)(?<=[bc])
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/921"
  "(.*?)(?<=[bc])"
  "abcd"
  '(:single-line nil)
  (list
    "ab"
    "ab" ) )

;;;; perl-584.retest/922: (.*?)(?<=[bc])c
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/922"
  "(.*?)(?<=[bc])c"
  "abcd"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; perl-584.retest/923: 2(]*)?$\1
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/923"
  "2(]*)?$\\1"
  "2"
  '(:single-line nil)
  (list
    "2"
    "" ) )

;;;; perl-584.retest/924: (??{})
;;;
;;;    Matched. (y)
;
(test-case
  "perl-584/924"
  "(??{})"
  "x"
  '(:single-line nil)
  (list "") )

;;;; perl-584.retest/925: a(b)??
;;;
;;;    Matched with 1 captures. (y)
;
(test-case    ; # undef [perl #16773]
  "perl-584/925"
  "a(b)??"
  "abc"
  '(:single-line nil)
  (list
    "a"
    nil ) )

;;;; perl-584.retest/926: (\d{1,3}\.){3,}
;;;
;;;    Matched with 1 captures. (y)
;
(test-case    ; # [perl #18019]
  "perl-584/926"
  "(\\d{1,3}\\.){3,}"
  "128.134.142.8"
  '(:single-line nil)
  (list
    "128.134.142."
    "142." ) )

;;;; perl-584.retest/927: ^.{3,4}(.+)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case    ; # 16 tests for [perl #23171]
  "perl-584/927"
  "^.{3,4}(.+)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/928: ^(?:f|o|b){3,4}(.+)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/928"
  "^(?:f|o|b){3,4}(.+)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/929: ^.{3,4}((?:b|a|r)+)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/929"
  "^.{3,4}((?:b|a|r)+)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/930: ^(?:f|o|b){3,4}((?:b|a|r)+)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/930"
  "^(?:f|o|b){3,4}((?:b|a|r)+)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/931: ^.{3,4}(.+?)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/931"
  "^.{3,4}(.+?)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/932: ^(?:f|o|b){3,4}(.+?)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/932"
  "^(?:f|o|b){3,4}(.+?)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/933: ^.{3,4}((?:b|a|r)+?)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/933"
  "^.{3,4}((?:b|a|r)+?)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/934: ^(?:f|o|b){3,4}((?:b|a|r)+?)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/934"
  "^(?:f|o|b){3,4}((?:b|a|r)+?)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/935: ^.{2,3}?(.+)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/935"
  "^.{2,3}?(.+)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/936: ^(?:f|o|b){2,3}?(.+)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/936"
  "^(?:f|o|b){2,3}?(.+)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/937: ^.{2,3}?((?:b|a|r)+)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/937"
  "^.{2,3}?((?:b|a|r)+)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/938: ^(?:f|o|b){2,3}?((?:b|a|r)+)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/938"
  "^(?:f|o|b){2,3}?((?:b|a|r)+)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/939: ^.{2,3}?(.+?)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/939"
  "^.{2,3}?(.+?)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/940: ^(?:f|o|b){2,3}?(.+?)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/940"
  "^(?:f|o|b){2,3}?(.+?)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/941: ^.{2,3}?((?:b|a|r)+?)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/941"
  "^.{2,3}?((?:b|a|r)+?)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/942: ^(?:f|o|b){2,3}?((?:b|a|r)+?)\1\z
;;;
;;;    Matched with 1 captures. (y)
;
(test-case
  "perl-584/942"
  "^(?:f|o|b){2,3}?((?:b|a|r)+?)\\1\\z"
  "foobarbar"
  '(:single-line nil)
  (list
    "foobarbar"
    "bar" ) )

;;;; perl-584.retest/943: .*a(?!(b|cd)*e).*f
;;;
;;;    Not mached. (n)
;
(test-case    ; # [perl #23030]
  "perl-584/943"
  ".*a(?!(b|cd)*e).*f"
  "......abef"
  '(:single-line nil)
  nil )

;;;; perl-584.retest/944: x(?#
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/944"
  "x(?#"
  "x"
  '(:single-line nil)
  :compile   ; Sequence (?#... not terminated in regex m/x(?#/
 )

;;;; perl-584.retest/945: :x(?#:
;;;
;;;    Syntax error. (c)
;
(test-case
  "perl-584/945"
  "x(?#"
  "x"
  '(:single-line nil)
  :compile   ; Sequence (?#... not terminated in regex m/x(?#/
 )

; EOF
